@orkastery/cli 0.5.3 → 0.6.0

package/dist/locale-verify.js

@@ -0,0 +1,201 @@
+"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] [--check classic|agile] [--canal C] [--esperar [min]]',
+    // RM-072 (D1): a opcao --check aceita so os dois modos, e o erro diz quais.
+    checkInvalido: (valor) => `ork verify: --check invalido: ${valor === null ? '(sem valor)' : JSON.stringify(valor)} (aceitos: classic, agile)`,
+    // ork verify --baseline
+    baselineGravada: (id) => `Baseline gravada para a thread ${id}.`,
+    // RM-037 (defeito 2 de 19 e 20/10/2026): a recusa diz o comando exato do preparo, ou como declara-lo.
+    baselineDependenciaAusente: (nome, code, comando, preparo) => `baseline.dependencia-ausente: ${nome} nao executou porque o comando nao existe (codigo ${code}): ${comando}; ` +
+        (preparo ? `rode na worktree da thread o preparo do manifesto (worktree.dependencias): ${preparo}; depois grave a baseline de novo`
+            : 'instale ou prepare as dependencias antes de gravar a baseline; para o ork preparar toda worktree nova, declare o ' +
+                'comando em worktree.dependencias no manifesto'),
+    // RM-037 (CHECK 3 da ork-rm037defeit2): o preparo que a criacao adiou falhou, e a operacao nao roda sem as dependencias.
+    dependenciasPendentesFalharam: (operacao, comando, code, estourou, dir, ultimaLinha) => `${operacao}.dependencia-ausente: o preparo adiado da worktree (worktree.dependencias) ` +
+        `${estourou ? 'estourou o prazo' : `saiu com codigo ${code}`}${ultimaLinha ? `: ${ultimaLinha}` : ''}; ` +
+        `${operacao === 'baseline' ? 'a baseline nao foi gravada' : 'o verify nao rodou'} sem as dependencias. Rode na worktree ` +
+        `cd ${dir} && ${comando}; ${operacao === 'baseline' ? 'a proxima baseline' : 'o proximo verify'} repete o preparo antes dos comandos`,
+    baselineCommit: (commit) => `  commit ${commit}`,
+    // RM-072 (D1): o modo do CHECK que gravou a baseline; o nome de produto e o mesmo nas duas linguas.
+    baselineCheck: (nome, modo, origem) => `  ${'check'.padEnd(10)} ${nome} (` +
+        `${origem === 'opcao' ? `opcao --check ${modo}` : origem === 'manifesto' ? `manifesto: check.mode: ${modo}`
+            : 'padrao: o manifesto nao declara check.mode'})`,
+    // RM-037 (defeito 1 de 19 e 20/10/2026): o comando sem veredito (estouro, sinal, relogio sob steal, nao rodou) nao vale
+    // como "ja falhava"; `situacao` e a do comando, no locale da impressao.
+    baselineComando: (nome, veredito, code, comando, situacao) => `  ${nome.padEnd(10)} ${veredito === 'passava' ? 'passava' : veredito === 'ja-falhava'
+        ? `ja falhava (codigo ${code})` : `SEM VEREDITO, ${situacao}: nao vale como "ja falhava"`}  ${comando}`,
+    baselineSemVeredito: (nomes, id) => `  sem veredito na baseline: ${nomes}; no verify, a falha deles sai ` +
+        `como falha sem baseline (verify.failed), nunca como pre-existente. Grave de novo com ork verify ${id} --baseline ` +
+        'numa hora de CPU livre, ou suba verify.timeout_ms_por_comando no manifesto',
+    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}`,
+    // RM-072 (D1, D17): todo CHECK diz o modo que rodou e de onde ele veio.
+    check: (nome, modo, origem) => `  check       ${nome} (` +
+        `${origem === 'opcao' ? `opcao --check ${modo}` : origem === 'manifesto' ? `manifesto: check.mode: ${modo}`
+            : 'padrao: o manifesto nao declara check.mode'})`,
+    baseline: (sha, quando) => `  baseline    ${sha} de ${quando}`,
+    semBaseline: '  baseline    (nao gravada: falha nao pode ser chamada de regressao)',
+    // RM-072 (D8): o que o Agile fez na rodada, e cada peca que caiu para o equivalente do Classic.
+    agile: (reaproveitadas, inteiras, paralelo, lanes) => `  agile       ${reaproveitadas} comando(s) de claim contra o produto do preparo, ${inteiras} inteiro(s); ` +
+        `${paralelo ? `grupo em paralelo${lanes.length ? ` com as lanes ${lanes.join(', ')}` : ''}` : 'comandos do manifesto em serie'}`,
+    agileFallback: (peca, motivo, fallback) => `  fallback    ${peca}: ${motivo || 'sem motivo dito'}; rodou ${fallback || 'o equivalente do Classic'}`,
+    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}`,
+    falhaComBaselineSemVeredito: (nome, comando) => `  sem baseline   ${nome}: ${comando} (a baseline nao teve veredito dele)`,
+    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'}.`,
+    // RM-062 (F2): a barreira de dado privado (policy `dado_privado`); o valor casado e o termo nunca saem.
+    dadoPrivadoTitulo: (severidade) => `Dado privado (policy dado_privado em ${severidade}):`,
+    dadoPrivadoEscopoArvore: 'arvore versionada inteira (sem base para o diff)',
+    dadoPrivadoEscopoDiff: (sha, ref) => `diff da thread contra ${sha} (${ref ? `merge-base com ${ref}` : 'base carimbada da thread'})`,
+    dadoPrivadoEscopoTexto: (nome) => `texto de ${nome}`,
+    dadoPrivadoEscopo: (escopo, arquivos, linhas, nomes) => `  escopo       ${escopo}: ${arquivos} arquivo(s), ${linhas} linha(s), ${nomes} nome(s)`,
+    dadoPrivadoListaPresente: (termos, de) => `  lista local  ${termos} termo(s) de ${de}`,
+    dadoPrivadoListaAusente: (onde) => `  lista local  ausente (procurada em ${onde}): so os padroes genericos (home, email, hostname)`,
+    dadoPrivadoErro: (erro) => `  NAO RODOU    ${erro}`,
+    dadoPrivadoAchados: (n) => n ? `  achados      ${n} (o valor casado nunca e impresso)` : '  achados      nenhum',
+    dadoPrivadoAchado: (arquivo, linha, coluna, padrao, termo) => `    ${linha === null ? `${arquivo}  nome do arquivo` : `${arquivo}:${linha}:${coluna}`}  ${padrao}${termo ? ` (termo ${termo})` : ''}`,
+    dadoPrivadoMais: (n) => `    ... e mais ${n}`,
+};
+exports.VERIFY_EN = {
+    uso: 'usage: ork verify <thread-id> [--baseline] [--so-claims] [--check classic|agile] [--canal C] [--esperar [min]]',
+    checkInvalido: (valor) => `ork verify: invalid --check: ${valor === null ? '(no value)' : JSON.stringify(valor)} (accepted: classic, agile)`,
+    baselineGravada: (id) => `Baseline recorded for thread ${id}.`,
+    baselineDependenciaAusente: (nome, code, comando, preparo) => `baseline.missing-dependency: ${nome} did not run because the command does not exist (exit ${code}): ${comando}; ` +
+        (preparo ? `run the manifest preparation (\`worktree.dependencias\`) in the thread worktree: \`${preparo}\`; then record the baseline again`
+            : 'install or prepare dependencies before recording the baseline; for ork to prepare every new worktree, declare the ' +
+                'command in `worktree.dependencias` in the manifest'),
+    dependenciasPendentesFalharam: (operacao, comando, code, estourou, dir, ultimaLinha) => `${operacao}.missing-dependency: the deferred worktree preparation (\`worktree.dependencias\`) ` +
+        `${estourou ? 'ran past its deadline' : `exited with code ${code}`}${ultimaLinha ? `: ${ultimaLinha}` : ''}; ` +
+        `${operacao === 'baseline' ? 'the baseline was not recorded' : 'verify did not run'} without the dependencies. Run in the ` +
+        `worktree \`cd ${dir} && ${comando}\`; ${operacao === 'baseline' ? 'the next baseline' : 'the next verify'} repeats the ` +
+        'preparation before the commands',
+    baselineCommit: (commit) => `  commit ${commit}`,
+    baselineCheck: (nome, modo, origem) => `  ${'check'.padEnd(10)} ${nome} (${origem === 'opcao' ? `option --check ${modo}`
+        : origem === 'manifesto' ? `manifest: check.mode: ${modo}` : 'default: the manifest does not declare check.mode'})`,
+    baselineComando: (nome, veredito, code, comando, situacao) => `  ${nome.padEnd(10)} ${veredito === 'passava' ? 'passed'
+        : veredito === 'ja-falhava' ? `already failing (exit ${code})` : `NO VERDICT, ${situacao}: does not count as "already failing"`}  ${comando}`,
+    baselineSemVeredito: (nomes, id) => `  no verdict in the baseline: ${nomes}; in verify, their failure is reported as a ` +
+        `failure without a baseline (\`verify.failed\`), never as pre-existing. Record it again with \`ork verify ${id} --baseline\` ` +
+        'when the CPU is free, or raise `verify.timeout_ms_por_comando` in the manifest',
+    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}`,
+    check: (nome, modo, origem) => `  check       ${nome} (${origem === 'opcao' ? `option --check ${modo}`
+        : origem === 'manifesto' ? `manifest: check.mode: ${modo}` : 'default: the manifest does not declare check.mode'})`,
+    baseline: (sha, quando) => `  baseline    ${sha} from ${quando}`,
+    semBaseline: '  baseline    (not recorded: a failure cannot be called a regression)',
+    agile: (reaproveitadas, inteiras, paralelo, lanes) => `  agile       ${reaproveitadas} claim command(s) against the prepared product, ${inteiras} in full; ` +
+        `${paralelo ? `parallel group${lanes.length ? ` with lanes ${lanes.join(', ')}` : ''}` : 'manifest commands in series'}`,
+    agileFallback: (peca, motivo, fallback) => `  fallback    ${peca}: ${motivo || 'no reason given'}; ran ${fallback || 'the Classic equivalent'}`,
+    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}`,
+    falhaComBaselineSemVeredito: (nome, comando) => `  no baseline    ${nome}: ${comando} (the baseline had no verdict for it)`,
+    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'}.`,
+    dadoPrivadoTitulo: (severidade) => `Private data (policy dado_privado at ${severidade}):`,
+    dadoPrivadoEscopoArvore: 'whole versioned tree (no base for the diff)',
+    dadoPrivadoEscopoDiff: (sha, ref) => `thread diff against ${sha} (${ref ? `merge-base with ${ref}` : 'the thread stamped base'})`,
+    dadoPrivadoEscopoTexto: (nome) => `text of ${nome}`,
+    dadoPrivadoEscopo: (escopo, arquivos, linhas, nomes) => `  scope        ${escopo}: ${arquivos} file(s), ${linhas} line(s), ${nomes} name(s)`,
+    dadoPrivadoListaPresente: (termos, de) => `  local list   ${termos} term(s) from ${de}`,
+    dadoPrivadoListaAusente: (onde) => `  local list   missing (looked in ${onde}): only the generic patterns (home, email, hostname)`,
+    dadoPrivadoErro: (erro) => `  DID NOT RUN  ${erro}`,
+    dadoPrivadoAchados: (n) => n ? `  findings     ${n} (the matched value is never printed)` : '  findings     none',
+    dadoPrivadoAchado: (arquivo, linha, coluna, padrao, termo) => `    ${linha === null ? `${arquivo}  file name` : `${arquivo}:${linha}:${coluna}`}  ${padrao}${termo ? ` (term ${termo})` : ''}`,
+    dadoPrivadoMais: (n) => `    ... and ${n} more`,
+};

package/dist/locale-worktree.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * RM-061, fatia F3b: a familia `worktree` do catalogo de mensagens (`ork worktree ensure|sync|audit|release`). O
+ * pt-BR e a fonte; o ingles e tipado por ele. Sem import do nucleo: o que vem do estado entra por parametro.
+ *
+ * O detalhe e a correcao que o comando grava no ledger (`worktree_synced`, `worktree_audited`, `worktree_released`) e
+ * devolve no resultado nascem em pt-BR no escopo da gravacao (`textoDoCatalogo`), e so a impressao os remonta no
+ * locale (G4). O nome de cada check do audit e dado gravado: so a impressao o traduz, pelo id. Motivo tipado, comando,
+ * caminho e sha saem iguais nas duas linguas.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKTREE_EN = exports.WORKTREE_PT_BR = void 0;
+const NOMES_DOS_CHECKS_EN = {
+    registro: 'record', diretorio: 'directory', git: 'git', branch: 'branch', procedencia: 'provenance', arvore: 'tree',
+    base: 'base', artefatos: 'artifacts', 'estado-unico': 'single-state',
+};
+/** O motivo de a confirmacao local nao valer (`lerArquivoPrivado`, `lerWorktreeLocal`), pela frase exata, em ingles. */
+const MOTIVOS_DA_CONFIRMACAO_EN = [
+    [/^sem confirmação local$/, () => 'no local confirmation'],
+    [/^\.orkastery\/private precisa ser pasta 0700 do próprio usuário$/, () => '.orkastery/private must be a 0700 folder owned by the user'],
+    [/^(.+) precisa ser arquivo 0600 do próprio usuário$/, (nome) => `${nome} must be a 0600 file owned by the user`],
+    [/^(.+) está versionado no git e não vale como confirmação local$/, (nome) => `${nome} is versioned in git and does not count as a local confirmation`],
+    [/^(.+) com JSON inválido$/, (nome) => `${nome} has invalid JSON`],
+    [/^(.+) fora do contrato (.+)$/, (nome, contrato) => `${nome} does not follow the ${contrato} contract`],
+    [/^a confirmação local é de outro checkout$/, () => 'the local confirmation belongs to another checkout'],
+];
+exports.WORKTREE_PT_BR = {
+    uso: 'uso: ork worktree <ensure|sync|audit|release> <thread-id>',
+    // A moldura dos bloqueios: o mesmo bloco nos quatro subcomandos.
+    naoGarantida: (id) => `Worktree da thread ${id} NAO garantida.`,
+    syncBloqueado: (id) => `Sync da worktree da thread ${id} BLOQUEADO.`,
+    releaseBloqueado: (id) => `Release da worktree da thread ${id} BLOQUEADO.`,
+    motivoTipado: (motivo) => `  motivo tipado: ${motivo}`,
+    detalhe: (detalhe) => `  detalhe: ${detalhe}`,
+    correcao: (correcao) => `  correcao: ${correcao}`,
+    // ensure
+    criada: (id) => `Worktree criada para a thread ${id}.`,
+    jaExistia: (id) => `Worktree ja existia para a thread ${id}.`,
+    linhaDir: (dir) => `  dir     ${dir}`,
+    linhaBranch: (branch) => `  branch  ${branch}`,
+    linhaBase: (base) => `  base    ${base} (resolvida pelo ork, nao pelo executor)`,
+    // RM-037 (defeito 2 de 19 e 20/10/2026): o preparo de `worktree.dependencias` na worktree nova (thread new e ensure).
+    dependenciasProntas: (comando, segundos) => `  dependencias  ${comando} (worktree.dependencias) ok em ${segundos} s`,
+    dependenciasFalharam: (comando, code, estourou, dir, ultimaLinha) => `Aviso: o preparo das dependencias da worktree (worktree.dependencias) ${estourou ? 'estourou o prazo' : `saiu com codigo ${code}`}` +
+        `${ultimaLinha ? `: ${ultimaLinha}` : ''}. A thread e a worktree ficam; antes do build e da baseline, rode na worktree: ` +
+        `cd ${dir} && ${comando}`,
+    naoRegistrada: (dir) => `${dir} existe mas nao aparece em \`git worktree list\``,
+    naoRegistradaCorrecao: (id) => `remova o diretorio ou registre a worktree; depois rode: ork worktree ensure ${id}`,
+    reconcilieOEstado: (id) => `reconcilie o estado e rode ork worktree sync ${id}`,
+    jaExiste: 'a worktree da thread ja existe e o git a reconhece',
+    recriadaSobreBranch: (branch) => `worktree recriada sobre a branch ${branch}, que ja existia`,
+    criadaAPartirDe: (base) => `worktree criada a partir de ${base}`,
+    // sync
+    syncEnsaio: (id) => `Sync (--dry-run) da thread ${id}: nada foi executado.`,
+    syncFeito: (id) => `Sync da thread ${id}.`,
+    syncBase: (base, sha) => `  base       ${base} @ ${sha}`,
+    syncBranch: (branch, antes, depois) => `  branch     ${branch} @ ${antes} -> ${depois}`,
+    syncRebase: (estado) => `  rebase     ${estado}`,
+    comandosReais: '  Comandos reais, na ordem:',
+    semWorktree: (id) => `a thread ${id} nao tem worktree registrada no git`,
+    semWorktreeCorrecao: (id) => `crie a worktree com: ork worktree ensure ${id}`,
+    semStatus: (dir) => `${dir} nao respondeu a \`git status\``,
+    arvoreSuja: (dir) => `${dir} tem alteracao nao commitada; rebase em arvore suja perde trabalho`,
+    arvoreSujaCorrecao: (dir, id) => `commite ou guarde as alteracoes em ${dir} e rode de novo: ork worktree sync ${id}`,
+    reconcilieAsCopias: 'reconcilie as duas cópias sem descartar evidências',
+    baseInexistente: (base) => `a base ${base} do manifesto nao existe neste repositorio`,
+    baseInexistenteCorrecao: (caminho) => `corrija worktree.base_branch em ${caminho}`,
+    /** O que o ledger guarda quando a base ja estava na branch (o texto impresso e `jaIncorporada`). */
+    jaEraAncestral: 'a base ja era ancestral do HEAD da thread',
+    jaIncorporada: (base) => `a base ${base} ja esta incorporada: nada a sincronizar`,
+    semCommitProprio: (branch, base) => `a branch ${branch} nao tem commit proprio: o sync real a recriaria na base ${base} atual, sem rebase`,
+    inspecioneAsCopias: 'inspecione a cópia local e a fonte canônica preservadas antes de repetir o sync',
+    recriacaoFalhou: (branch, saida) => `a recriacao da branch ${branch} na base falhou: ${saida}`,
+    confiraAWorktree: (dir, id) => `confira a worktree ${dir} e rode de novo: ork worktree sync ${id}`,
+    recriada: (base, semAncestral) => `branch sem commit proprio recriada a partir da base ${base} atual` +
+        (semAncestral ? '; a base foi reescrita e nao tinha historia em comum com ela' : ''),
+    ondeComecou: '<commit onde a branch da thread comecou>',
+    semHistoriaComum: (base, branch, proprios) => `a base ${base} foi reescrita e nao tem historia ` +
+        `em comum com a branch ${branch}, que tem ${proprios ?? 'um numero desconhecido de'} commit(s) proprio(s): o rebase reaplicaria a ` +
+        'historia antiga inteira',
+    reaplique: (comando) => `reaplique so os commits da thread sobre a base nova: ${comando}`,
+    passoBaseReescrita: (ponto, sha) => `git merge-base --is-ancestor ${ponto} ${sha}   (falso: a base foi reescrita)`,
+    baseReescrita: (base, ponto, branch, sairam, proprios, comando) => `a base ${base} foi reescrita: o ponto de partida ${ponto} da branch ${branch} nao esta mais nela, ` +
+        `e o rebase comum reaplicaria ${sairam ?? 'um numero desconhecido de'} commit(s) que sairam da base junto com ` +
+        `o(s) ${proprios ?? '?'} da thread (${comando})`,
+    rebaseAcima: (base) => `a base ${base} avancou; o sync real faria o rebase acima`,
+    rebaseConflitou: (base, saida) => `o rebase sobre ${base} conflitou e foi abortado: ${saida}`,
+    rebaseConflitouCorrecao: (dir, sha) => `resolva o conflito na worktree ${dir} (git rebase ${sha} e resolucao manual), ` +
+        'ou reduza a regiao da thread com um lease path:<glob> menor',
+    /** O que o ledger guarda depois do rebase (o texto impresso e `rebasadaSobreEla`). */
+    rebasada: (base) => `branch da thread rebasada sobre ${base}`,
+    rebasadaSobreEla: (base, branch) => `a base ${base} avancou e a branch ${branch} foi rebasada sobre ela`,
+    // audit
+    auditoria: (id) => `Auditoria da worktree da thread ${id}`,
+    nomeDoCheck: (nome) => nome,
+    correcaoDoCheck: (correcao) => `         correcao: ${correcao}`,
+    consistente: '  worktree consistente: o git confirma cada item acima.',
+    divergencias: (n) => `  ${n} divergencia(s) encontrada(s) no proprio git.`,
+    apontaPara: (dir) => `thread.json aponta para ${dir}`,
+    semRegistroNoThread: 'a thread nao tem worktree registrada no thread.json',
+    naoExisteNoDisco: (dir) => `${dir} nao existe no disco`,
+    apareceNoGit: 'aparece em `git worktree list --porcelain`',
+    naoApareceNoGit: (dir) => `${dir} nao aparece em \`git worktree list\``,
+    emCheckout: (branch) => `${branch} em check-out`,
+    branchErrada: (esperada, encontrada) => `esperado ${esperada}, encontrado "${encontrada || '(HEAD solto)'}"`,
+    arvoreLimpa: 'sem alteracao nao commitada',
+    statusSemResposta: '`git status` nao respondeu neste diretorio',
+    alteracaoNaWorktree: 'ha alteracao nao commitada na worktree',
+    baseIncorporada: (base, sha) => `${base} @ ${sha} ja incorporada`,
+    baseAdiante: (base, sha) => `a base ${base} avancou para ${sha} e nao esta na branch da thread`,
+    artefatosDentro: (dir) => `os artefatos da thread estao DENTRO da worktree (${dir})`,
+    artefatosDentroCorrecao: 'os artefatos da thread vivem em .orkastery/threads/<id>, fora da arvore',
+    artefatosFora: (dir) => `${dir} fica fora da worktree`,
+    // release
+    liberada: (id) => `Worktree da thread ${id} liberada.`,
+    releaseDir: (dir) => `  dir      ${dir}`,
+    releaseRemovida: (removida) => `  removida ${removida ? 'sim' : 'nao (o diretorio ja nao existia)'}`,
+    releaseLeases: (leases) => `  leases   ${leases || '(nenhum lease de escrita para soltar)'}`,
+    /** O que o ledger guarda quando o diretorio ja tinha sumido (o texto impresso e `jaNaoExistiaImpresso`). */
+    jaNaoExistia: 'o diretorio ja nao existia; o registro foi limpo',
+    jaNaoExistiaImpresso: 'o diretorio ja nao existia; registro limpo e `git worktree prune` rodado',
+    confiraODiretorio: (id) => `confira o diretorio e o thread.json da thread ${id}`,
+    releaseArvoreSuja: (dir) => `${dir} tem alteracao nao commitada`,
+    releaseArvoreSujaCorrecao: (dir) => `commite o que interessa em ${dir}, ou repita com --forcar para descartar`,
+    removeFalhou: (saida) => `git worktree remove falhou: ${saida}`,
+    removeFalhouCorrecao: (dir) => `rode \`git worktree remove ${dir}\` na mao e confira \`git worktree list\``,
+    continuaNaLista: (dir) => `${dir} continua em \`git worktree list\` depois do remove`,
+    removida: (branch) => `worktree removida; a branch ${branch} continua no repositorio`,
+    // A pasta das worktrees e a criacao (`worktree-local.ts` e `criarWorktree`, em `thread.ts`)
+    dirForaDaRaiz: (pedido, dir, confirmada, motivo, comando) => `worktree.dir-fora-da-raiz: o orkastery.yaml pede worktree.dir: ${pedido}, ` +
+        `que leva a ${dir}, fora da raiz do projeto (pelo caminho real), e esta máquina não confirmou essa pasta ` +
+        `(${confirmada ? `a máquina confirmou ${confirmada}` : motivo ?? 'sem confirmação local'}). ` +
+        'Nenhuma worktree foi criada. O manifesto vem com o repositório; quem decide criar checkout fora da raiz é a ' +
+        `máquina. Para aceitar nesta máquina: ${comando} (ou volte worktree.dir para dentro do projeto, ` +
+        'como .claude/worktrees).',
+    worktreeJaExisteEm: (dir) => `worktree ja existe em ${dir}`,
+    baseRemotaFalhou: (remoto, base, saida) => `worktree.base-remota-indisponivel: git fetch de ${remoto}/${base} falhou; nenhuma worktree foi criada: ${saida}`,
+    worktreeAddFalhou: (saida) => `git worktree add falhou: ${saida}`,
+    worktreeNaoApareceu: (dir) => `worktree nao apareceu em \`git worktree list\` apos a criacao: ${dir}`,
+};
+exports.WORKTREE_EN = {
+    uso: 'usage: ork worktree <ensure|sync|audit|release> <thread-id>',
+    naoGarantida: (id) => `Worktree for thread ${id} NOT ensured.`,
+    syncBloqueado: (id) => `Worktree sync for thread ${id} BLOCKED.`,
+    releaseBloqueado: (id) => `Worktree release for thread ${id} BLOCKED.`,
+    motivoTipado: (motivo) => `  typed reason: ${motivo}`,
+    detalhe: (detalhe) => `  detail: ${detalhe}`,
+    correcao: (correcao) => `  fix: ${correcao}`,
+    criada: (id) => `Worktree created for thread ${id}.`,
+    jaExistia: (id) => `Worktree already existed for thread ${id}.`,
+    linhaDir: (dir) => `  dir     ${dir}`,
+    linhaBranch: (branch) => `  branch  ${branch}`,
+    linhaBase: (base) => `  base    ${base} (resolved by ork, not by the executor)`,
+    dependenciasProntas: (comando, segundos) => `  dependencies  ${comando} (\`worktree.dependencias\`) ok in ${segundos} s`,
+    dependenciasFalharam: (comando, code, estourou, dir, ultimaLinha) => `Warning: preparing the worktree dependencies (\`worktree.dependencias\`) ${estourou ? 'ran past its deadline' : `exited with code ${code}`}` +
+        `${ultimaLinha ? `: ${ultimaLinha}` : ''}. The thread and the worktree stay; before the build and the baseline, run in the worktree: ` +
+        `\`cd ${dir} && ${comando}\``,
+    naoRegistrada: (dir) => `${dir} exists but does not show up in \`git worktree list\``,
+    naoRegistradaCorrecao: (id) => `remove the directory or register the worktree; then run: ork worktree ensure ${id}`,
+    reconcilieOEstado: (id) => `reconcile the state and run \`ork worktree sync ${id}\``,
+    jaExiste: 'the thread worktree already exists and git recognizes it',
+    recriadaSobreBranch: (branch) => `worktree recreated on branch ${branch}, which already existed`,
+    criadaAPartirDe: (base) => `worktree created from ${base}`,
+    syncEnsaio: (id) => `Sync (--dry-run) of thread ${id}: nothing was run.`,
+    syncFeito: (id) => `Sync of thread ${id}.`,
+    syncBase: (base, sha) => `  base       ${base} @ ${sha}`,
+    syncBranch: (branch, antes, depois) => `  branch     ${branch} @ ${antes} -> ${depois}`,
+    syncRebase: (estado) => `  rebase     ${{ feito: 'done', desnecessario: 'not needed', 'seria feito': 'would run' }[estado]}`,
+    comandosReais: '  Real commands, in order:',
+    semWorktree: (id) => `thread ${id} has no worktree registered in git`,
+    semWorktreeCorrecao: (id) => `create the worktree with: ork worktree ensure ${id}`,
+    semStatus: (dir) => `${dir} did not answer \`git status\``,
+    arvoreSuja: (dir) => `${dir} has uncommitted changes; rebasing a dirty tree loses work`,
+    arvoreSujaCorrecao: (dir, id) => `commit or stash the changes in ${dir} and run again: \`ork worktree sync ${id}\``,
+    reconcilieAsCopias: 'reconcile the two copies without discarding evidence',
+    baseInexistente: (base) => `the base ${base} from the manifest does not exist in this repository`,
+    baseInexistenteCorrecao: (caminho) => `fix \`worktree.base_branch\` in ${caminho}`,
+    jaEraAncestral: 'the base was already an ancestor of the thread HEAD',
+    jaIncorporada: (base) => `the base ${base} is already merged in: nothing to sync`,
+    semCommitProprio: (branch, base) => `branch ${branch} has no commit of its own: the real sync would recreate it on the current base ${base}, without a rebase`,
+    inspecioneAsCopias: 'inspect the preserved local copy and canonical source before repeating the sync',
+    recriacaoFalhou: (branch, saida) => `recreating branch ${branch} on the base failed: ${saida}`,
+    confiraAWorktree: (dir, id) => `check the worktree ${dir} and run again: \`ork worktree sync ${id}\``,
+    recriada: (base, semAncestral) => `branch with no commit of its own recreated from the current base ${base}` +
+        (semAncestral ? '; the base was rewritten and had no history in common with it' : ''),
+    ondeComecou: '<commit where the thread branch started>',
+    semHistoriaComum: (base, branch, proprios) => `the base ${base} was rewritten and has no history in common with branch ${branch}, ` +
+        `which has ${proprios ?? 'an unknown number of'} commit(s) of its own: the rebase would replay the whole old history`,
+    reaplique: (comando) => `replay only the thread commits on top of the new base: ${comando}`,
+    passoBaseReescrita: (ponto, sha) => `git merge-base --is-ancestor ${ponto} ${sha}   (false: the base was rewritten)`,
+    baseReescrita: (base, ponto, branch, sairam, proprios, comando) => `the base ${base} was rewritten: the starting point ${ponto} of ` +
+        `branch ${branch} is no longer in it, and a plain rebase would replay ${sairam ?? 'an unknown number of'} commit(s) that left the ` +
+        `base along with the thread's ${proprios ?? '?'} (${comando})`,
+    rebaseAcima: (base) => `the base ${base} moved ahead; the real sync would run the rebase above`,
+    rebaseConflitou: (base, saida) => `the rebase onto ${base} hit a conflict and was aborted: ${saida}`,
+    rebaseConflitouCorrecao: (dir, sha) => `resolve the conflict in the worktree ${dir} (git rebase ${sha} and manual resolution), ` +
+        'or narrow the thread region with a smaller `path:<glob>` lease',
+    rebasada: (base) => `thread branch rebased onto ${base}`,
+    rebasadaSobreEla: (base, branch) => `the base ${base} moved ahead and branch ${branch} was rebased onto it`,
+    auditoria: (id) => `Audit of the worktree of thread ${id}`,
+    nomeDoCheck: (nome) => NOMES_DOS_CHECKS_EN[nome] ?? nome,
+    correcaoDoCheck: (correcao) => `         fix: ${correcao}`,
+    consistente: '  worktree consistent: git confirms every item above.',
+    divergencias: (n) => `  ${n} divergence(s) found in git itself.`,
+    apontaPara: (dir) => `thread.json points to ${dir}`,
+    semRegistroNoThread: 'the thread has no worktree recorded in thread.json',
+    naoExisteNoDisco: (dir) => `${dir} does not exist on disk`,
+    apareceNoGit: 'shows up in `git worktree list --porcelain`',
+    naoApareceNoGit: (dir) => `${dir} does not show up in \`git worktree list\``,
+    emCheckout: (branch) => `${branch} checked out`,
+    branchErrada: (esperada, encontrada) => `expected ${esperada}, found "${encontrada || '(detached HEAD)'}"`,
+    arvoreLimpa: 'no uncommitted changes',
+    statusSemResposta: '`git status` did not answer in this directory',
+    alteracaoNaWorktree: 'the worktree has uncommitted changes',
+    baseIncorporada: (base, sha) => `${base} @ ${sha} already merged in`,
+    baseAdiante: (base, sha) => `the base ${base} moved ahead to ${sha} and is not in the thread branch`,
+    artefatosDentro: (dir) => `the thread artifacts are INSIDE the worktree (${dir})`,
+    artefatosDentroCorrecao: 'the thread artifacts live in `.orkastery/threads/<id>`, outside the tree',
+    artefatosFora: (dir) => `${dir} stays outside the worktree`,
+    liberada: (id) => `Worktree of thread ${id} released.`,
+    releaseDir: (dir) => `  dir      ${dir}`,
+    releaseRemovida: (removida) => `  removed  ${removida ? 'yes' : 'no (the directory no longer existed)'}`,
+    releaseLeases: (leases) => `  leases   ${leases || '(no write lease to release)'}`,
+    jaNaoExistia: 'the directory no longer existed; the record was cleaned',
+    jaNaoExistiaImpresso: 'the directory no longer existed; record cleaned and `git worktree prune` run',
+    confiraODiretorio: (id) => `check the directory and the thread.json of thread ${id}`,
+    releaseArvoreSuja: (dir) => `${dir} has uncommitted changes`,
+    releaseArvoreSujaCorrecao: (dir) => `commit what matters in ${dir}, or repeat with \`--forcar\` to discard it`,
+    removeFalhou: (saida) => `git worktree remove failed: ${saida}`,
+    removeFalhouCorrecao: (dir) => `run \`git worktree remove ${dir}\` by hand and check \`git worktree list\``,
+    continuaNaLista: (dir) => `${dir} is still in \`git worktree list\` after the remove`,
+    removida: (branch) => `worktree removed; branch ${branch} stays in the repository`,
+    dirForaDaRaiz: (pedido, dir, confirmada, motivo, comando) => {
+        const regra = motivo ? MOTIVOS_DA_CONFIRMACAO_EN.find(([re]) => re.test(motivo)) : undefined;
+        const porque = confirmada ? `the machine confirmed ${confirmada}`
+            : motivo ? (regra ? regra[1](...(regra[0].exec(motivo) ?? []).slice(1)) : motivo) : 'no local confirmation';
+        return `worktree.dir-fora-da-raiz: \`orkastery.yaml\` asks for worktree.dir: ${pedido}, which leads to ${dir}, outside the ` +
+            `project root (by the real path), and this machine did not confirm that folder (${porque}). No worktree was created. ` +
+            'The manifest comes with the repository; the machine decides whether to create a checkout outside the root. ' +
+            `To accept it on this machine: \`${comando}\` (or move worktree.dir back inside the project, such as .claude/worktrees).`;
+    },
+    worktreeJaExisteEm: (dir) => `a worktree already exists at ${dir}`,
+    baseRemotaFalhou: (remoto, base, saida) => `worktree.remote-base-unavailable: git fetch of ${remoto}/${base} failed; no worktree was created: ${saida}`,
+    worktreeAddFalhou: (saida) => `git worktree add failed: ${saida}`,
+    worktreeNaoApareceu: (dir) => `the worktree did not show up in \`git worktree list\` after it was created: ${dir}`,
+};