@orkastery/cli 0.5.6 → 0.6.1

package/dist/locale-thread.js

@@ -9,8 +9,9 @@
  * 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 = {
+exports.THREAD_EN = exports.THREAD_PT_BR = exports.PAUSA_SOBRE_EN = void 0;
+/** O assunto da pausa de cada bloco (`modos.ts`) em ingles: um mapa so, para o `thread` e para o prompt de fase. */
+exports.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',
 };
@@ -19,7 +20,7 @@ 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' },
+        worktree: 'worktree', conducao: 'conducao', score: 'score', check: 'check' },
     modo: (tag, pausas) => `${tag} (${pausas} pausas humanas previstas)`,
     cicloPadrao: 'padrao do modo',
     status: (status) => status,
@@ -28,6 +29,9 @@ exports.THREAD_PT_BR = {
     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}`,
+    /** RM-072 (D17): o modo do ultimo `verify_run`; o nome de produto ("Agile Check", "Classic Check") e o mesmo nas duas linguas. */
+    check: (nome, origem, quando, sha) => `${nome}, ${origem === 'opcao' ? 'pela opcao --check' : origem === 'manifesto' ? 'pelo manifesto' : 'pelo padrao'}, ` +
+        `no verify de ${quando} (${sha})`,
     blocosPrevistos: '  blocos previstos',
     pausaPrevista: (sobre) => `pausa prevista: ${sobre}`,
     pausaSobre: (sobre) => sobre,
@@ -48,6 +52,7 @@ exports.THREAD_PT_BR = {
         'fix.reverify': 'ork fix reverify',
         'mcp.verify': 'ork_verify (MCP)',
         handoff: 'reserva de quem assumiu',
+        'branch.atualizar': 'merge da base na branch',
     },
     // ork thread new
     criada: 'Thread criada.',
@@ -119,6 +124,58 @@ exports.THREAD_PT_BR = {
     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 new --from-finding. IDs, códigos, claims e valores do achado continuam dados.
+    fromFinding: {
+        achadoNaoExiste: (id, board) => `achado "${id}" nao existe no board de divida (${board}). Veja: ork audit divida`,
+        recusada: (id) => `Thread a partir do achado ${id} RECUSADA.`,
+        descricaoDoMotivo: (_motivo, descricao) => descricao,
+        motivoTipado: (motivo) => `  motivo tipado: ${motivo}`,
+        detalhe: (detalhe) => `  detalhe: ${detalhe}`,
+        correcao: (correcao) => `  correcao: ${correcao}`,
+        criada: (id) => `Thread criada a partir do achado ${id}.`,
+        simulacao: 'Simulacao (--dry-run), nada foi gravado.',
+        origemDoGoal: (id) => `  origem do GOAL: .orkastery/threads/${id}/achado.json`,
+        pedidoMontado: 'Pedido de GOAL ja montado a partir do achado:',
+        proximoPasso: 'Proximo passo:',
+        comandoDoProximoPasso: (id) => `  ork phase run ${id} GOAL --prompt "$(cat .orkastery/threads/${id}/pedido-goal.md)"`,
+        jaVirouThread: (achado, thread) => `o achado ${achado} ja originou a thread ${thread}`,
+        continueNaThread: (thread) => `continue naquela thread: ork thread status ${thread}`,
+        claimPendente: (claim) => `a claim ${claim} do achado ainda nao foi reexecutada no HEAD real: ` +
+            'o auditor nao tem direito a self-report',
+        proveOAchado: (rodada) => `prove o achado antes de abrir trabalho: ork audit verify ${rodada}`,
+        claimReprovada: (claim) => `a claim ${claim} do achado REPROVOU na reexecucao no HEAD real`,
+        descarteOAchado: 'o achado nao se sustenta: corrija a evidencia na rodada, ou descarte o achado, em vez de abrir thread sobre ele',
+        simulacaoDetalhe: 'simulacao (--dry-run): nenhuma thread e nenhum carimbo no board foram gravados',
+        claimSemComando: (claim) => `AVISO: a claim ${claim} do achado nao tem comando de verificacao ` +
+            '(motivo tipado claims.unverifiable, que avisa e nao bloqueia)',
+        achadoAberto: (achado, thread) => `achado ${achado} aberto como thread ${thread}, com a evidencia e a claim junto`,
+        achadoCabecalho: (id, severidade, pack, regra, titulo) => `  ${id}  [${severidade}] ${pack}/${regra}  ${titulo}`,
+        evidencia: (valor) => `      evidencia   ${valor}`,
+        descricao: (valor) => `      descricao   ${valor}`,
+        claim: (id, estado, alegacao) => `      claim       ${id} [${estado}] ${alegacao}`,
+        verificar: (comando) => `      verificar   ${comando}`,
+        semComando: '(sem comando: o auditor nao comprovou o achado)',
+        impacto: (valor) => `      impacto     ${valor}`,
+        fix: (valor) => `      fix         ${valor}`,
+        irreversivel: (valor) => `      irreversivel ${valor}`,
+        estimativa: (valor) => `      estimativa  ${valor}`,
+        destino: (destino, regime) => `      destino     ${destino} (regime ${regime})`,
+        estado: (estado, thread) => `      estado      ${estado}${thread ? ` (thread ${thread})` : ''}`,
+        pedidoCabecalho: (id, pack, regra, severidade) => `Achado de auditoria ${id} (pack ${pack}, regra ${regra}, severidade ${severidade}).`,
+        pedidoTitulo: (titulo) => `Titulo: ${titulo}`,
+        pedidoEvidencia: (evidencia) => `Evidencia: ${evidencia}`,
+        pedidoDescricao: (descricao) => `Descricao: ${descricao}`,
+        pedidoClaim: (id, estado, alegacao) => `Alegacao do auditor (claim ${id}, estado ${estado}): ${alegacao}`,
+        pedidoVerificar: (comando) => `Como reexecutar a evidencia: ${comando}`,
+        naoDeclarado: '(nao declarado pelo auditor)',
+        proposta: 'Proposta de ajuste levantada pela rodada:',
+        propostaImpacto: (valor) => `  impacto       ${valor}`,
+        propostaFix: (valor) => `  fix sugerido  ${valor}`,
+        propostaIrreversivel: (valor) => `  irreversivel  ${valor}`,
+        propostaEstimativa: (valor) => `  estimativa    ${valor}`,
+        origem: (rodada, produto, estagio, postura) => `Origem: rodada ${rodada}, produto ${produto}, estagio ${estagio}, postura ${postura}.`,
+        propostaNaoDecisao: 'O fix acima e proposta do auditor, nao decisao: valide no GOAL antes de implementar.',
+    },
     // ork thread status
     naoEncontrada: (id, dir) => `thread "${id}" nao encontrada em ${dir}`,
     usoStatus: 'uso: ork thread status <thread-id>',
@@ -146,11 +203,27 @@ exports.THREAD_PT_BR = {
     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}`,
+    // F3b (D1): ork thread list, close e entrega
+    colunasDaLista: ['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'PAUSAS', 'SESSOES'],
+    listaVazia: (todas, modo) => `${todas ? 'Nenhuma thread em .orkastery/threads.'
+        : 'Nenhuma thread aberta ou pausada (use --todas para ver as fechadas).'} Crie uma com: ork thread new "<nome>" --modo ${modo}`,
+    fechadasOmitidas: (n) => `  ${n} fechada(s) omitida(s). Use --todas para ver todas.`,
+    informeOId: 'informe o id da thread',
+    /** D14: as recusas de `thread close` e `thread entrega` (`thread-close.ts`), por `ErroDoCatalogo`. */
+    sha256Invalido: 'sha256 inválido',
+    artefatoForaDoProjeto: 'artefato deve estar dentro do projeto',
+    artefatoNaoRegular: 'artefato deve ser arquivo regular',
+    artefatoDiverge: 'hash do artefato diverge',
+    artefatoExige: 'artefato exige thread aberta e autoria explícita',
+    motivoDoFechamento: 'motivo deve ser orfa, engano ou superada',
+    fechamentoExige: 'fechamento exige autoria e justificativa',
+    encerradaPorOutroMotivo: 'thread já encerrada por outro motivo',
+    entregueExigeMaster: 'thread entregue ou pontuada exige MASTER, não fechamento administrativo',
 };
 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' },
+        worktree: 'worktree', conducao: 'conduction', score: 'score', check: 'check' },
     modo: (tag, pausas) => `${tag} (${pausas} planned human pause${pausas === 1 ? '' : 's'})`,
     cicloPadrao: 'default for the mode',
     status: (status) => STATUS_EN[status] ?? status,
@@ -159,9 +232,11 @@ exports.THREAD_EN = {
     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}`,
+    check: (nome, origem, quando, sha) => `${nome}, ${origem === 'opcao' ? 'by the --check option' : origem === 'manifesto'
+        ? 'by the manifest' : 'by default'}, in the verify of ${quando} (${sha})`,
     blocosPrevistos: '  planned blocks',
     pausaPrevista: (sobre) => `planned pause: ${sobre}`,
-    pausaSobre: (sobre) => PAUSA_SOBRE_EN[sobre] ?? sobre,
+    pausaSobre: (sobre) => exports.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}`,
@@ -177,6 +252,7 @@ exports.THREAD_EN = {
         'fix.reverify': 'ork fix reverify',
         'mcp.verify': 'ork_verify (MCP)',
         handoff: 'reservation of whoever took over',
+        'branch.atualizar': 'merge of the base into the branch',
     },
     criada: 'Thread created.',
     simulacao: 'Dry run (--dry-run): nothing was written.',
@@ -250,6 +326,60 @@ exports.THREAD_EN = {
     memoriaGravada: (tenant, gravados) => `Memory (orkmind, tenant ${tenant}): ${gravados}.`,
     nadaAGravar: 'nothing to write',
     gravacoesFalhas: (n) => `  ${n} write(s) not completed; see \`ork memory status\`.`,
+    fromFinding: {
+        achadoNaoExiste: (id, board) => `finding "${id}" does not exist on the debt board (${board}). See: \`ork audit divida\``,
+        recusada: (id) => `Thread from finding ${id} REFUSED.`,
+        descricaoDoMotivo: (motivo) => ({
+            'claims.failed': 'the finding claim has no passing proof on the real HEAD',
+            'claims.unverifiable': 'the finding claim has no executable verification command',
+            'achado.ja-virou-thread': 'the finding already opened a thread and cannot open another one',
+        }[motivo] ?? 'the typed audit rule refused the finding'),
+        motivoTipado: (motivo) => `  typed reason: ${motivo}`,
+        detalhe: (detalhe) => `  detail: ${detalhe}`,
+        correcao: (correcao) => `  fix: ${correcao}`,
+        criada: (id) => `Thread created from finding ${id}.`,
+        simulacao: 'Dry run (--dry-run): nothing was written.',
+        origemDoGoal: (id) => `  GOAL source: .orkastery/threads/${id}/achado.json`,
+        pedidoMontado: 'GOAL request already assembled from the finding:',
+        proximoPasso: 'Next step:',
+        comandoDoProximoPasso: (id) => `  ork phase run ${id} GOAL --prompt "$(cat .orkastery/threads/${id}/pedido-goal.md)"`,
+        jaVirouThread: (achado, thread) => `finding ${achado} already opened thread ${thread}`,
+        continueNaThread: (thread) => `continue in that thread: \`ork thread status ${thread}\``,
+        claimPendente: (claim) => `finding claim ${claim} has not been rerun on the real HEAD: the auditor cannot self-report`,
+        proveOAchado: (rodada) => `prove the finding before opening work: \`ork audit verify ${rodada}\``,
+        claimReprovada: (claim) => `finding claim ${claim} FAILED when rerun on the real HEAD`,
+        descarteOAchado: 'the finding is not supported: fix the evidence in the audit run or discard the finding instead of opening a thread',
+        simulacaoDetalhe: 'dry run: no thread or board stamp was written',
+        claimSemComando: (claim) => `WARNING: finding claim ${claim} has no verification command ` +
+            '(typed reason claims.unverifiable, which warns and does not block)',
+        achadoAberto: (achado, thread) => `finding ${achado} opened as thread ${thread}, with its evidence and claim`,
+        achadoCabecalho: (id, severidade, pack, regra, titulo) => `  ${id}  [${severidade}] ${pack}/${regra}  ${titulo}`,
+        evidencia: (valor) => `      evidence    ${valor}`,
+        descricao: (valor) => `      description ${valor}`,
+        claim: (id, estado, alegacao) => `      claim       ${id} [${estado}] ${alegacao}`,
+        verificar: (comando) => `      verify      ${comando}`,
+        semComando: '(no command: the auditor did not prove the finding)',
+        impacto: (valor) => `      impact      ${valor}`,
+        fix: (valor) => `      fix         ${valor}`,
+        irreversivel: (valor) => `      irreversible ${valor}`,
+        estimativa: (valor) => `      estimate    ${valor}`,
+        destino: (destino, regime) => `      destination ${destino} (${regime} regime)`,
+        estado: (estado, thread) => `      state       ${estado}${thread ? ` (thread ${thread})` : ''}`,
+        pedidoCabecalho: (id, pack, regra, severidade) => `Audit finding ${id} (pack ${pack}, rule ${regra}, severity ${severidade}).`,
+        pedidoTitulo: (titulo) => `Title: ${titulo}`,
+        pedidoEvidencia: (evidencia) => `Evidence: ${evidencia}`,
+        pedidoDescricao: (descricao) => `Description: ${descricao}`,
+        pedidoClaim: (id, estado, alegacao) => `Auditor claim (${id}, state ${estado}): ${alegacao}`,
+        pedidoVerificar: (comando) => `How to rerun the evidence: ${comando}`,
+        naoDeclarado: '(not declared by the auditor)',
+        proposta: 'Adjustment proposed by the audit run:',
+        propostaImpacto: (valor) => `  impact        ${valor}`,
+        propostaFix: (valor) => `  suggested fix ${valor}`,
+        propostaIrreversivel: (valor) => `  irreversible ${valor}`,
+        propostaEstimativa: (valor) => `  estimate      ${valor}`,
+        origem: (rodada, produto, estagio, postura) => `Source: run ${rodada}, product ${produto}, stage ${estagio}, stance ${postura}.`,
+        propostaNaoDecisao: 'The fix above is the auditor\'s proposal, not a decision: validate it in GOAL before implementing.',
+    },
     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})`,
@@ -274,4 +404,18 @@ exports.THREAD_EN = {
     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}`,
+    colunasDaLista: ['ID', 'SLUG', 'MODE', 'PHASE', 'STATUS', 'PAUSES', 'SESSIONS'],
+    listaVazia: (todas, modo) => `${todas ? 'No thread in `.orkastery/threads`.'
+        : 'No open or paused thread (use `--todas` to see the closed ones).'} Create one with \`ork thread new "<name>" --modo ${modo}\`.`,
+    fechadasOmitidas: (n) => `  ${n} closed thread(s) hidden. Use \`--todas\` to see all.`,
+    informeOId: 'pass the thread id',
+    sha256Invalido: 'invalid sha256',
+    artefatoForaDoProjeto: 'the artifact must be inside the project',
+    artefatoNaoRegular: 'the artifact must be a regular file',
+    artefatoDiverge: 'the artifact hash does not match',
+    artefatoExige: 'an artifact needs an open thread and an explicit author',
+    motivoDoFechamento: 'the reason must be `orfa`, `engano` or `superada`',
+    fechamentoExige: 'closing needs an author and a justification',
+    encerradaPorOutroMotivo: 'the thread was already closed for another reason',
+    entregueExigeMaster: 'a delivered or scored thread needs MASTER, not an administrative close',
 };

package/dist/locale-verify.js

@@ -10,11 +10,33 @@
 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]]',
+    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}`,
-    baselineComando: (nome, ok, code, comando) => `  ${nome.padEnd(10)} ${ok ? 'passava' : `ja falhava (codigo ${code})`}  ${comando}`,
+    // 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)',
@@ -22,8 +44,16 @@ exports.VERIFY_PT_BR = {
     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'}`,
@@ -55,6 +85,7 @@ exports.VERIFY_PT_BR = {
     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)
@@ -69,20 +100,53 @@ exports.VERIFY_PT_BR = {
     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] [--canal C] [--esperar [min]]',
+    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}`,
-    baselineComando: (nome, ok, code, comando) => `  ${nome.padEnd(10)} ${ok ? 'passed' : `already failing (exit ${code})`}  ${comando}`,
+    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)`,
@@ -110,6 +174,7 @@ exports.VERIFY_EN = {
     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',
@@ -122,4 +187,15 @@ exports.VERIFY_EN = {
     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}`,
+};