@orkastery/cli 0.5.6 → 0.6.0

package/dist/worktree-local.js

@@ -58,6 +58,7 @@ const path = __importStar(require("node:path"));
 const estado_thread_1 = require("./estado-thread");
 const postura_local_1 = require("./postura-local");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 exports.CONTRATO_WORKTREE_LOCAL = 'ork.worktree-local/v1';
 exports.ARQUIVO_WORKTREE_LOCAL = 'worktree-local.json';
 /**
@@ -115,24 +116,25 @@ exports.COMANDO_CONFIRMAR_WORKTREE = 'ork setup worktree confirmar';
  * a máquina confirmou exatamente essa pasta; senão o erro tipado com o comando que confirma.
  */
 function recusaDePastaDasWorktrees(raiz, manifesto) {
+    const montar = montadorDaRecusa(raiz, manifesto);
+    return montar ? montar((0, locale_1.msg)('pt-BR')) : null;
+}
+/** RM-061 (F3b): a recusa pelo catalogo, com o que ela cita lido antes; `null` quando a pasta vale. */
+function montadorDaRecusa(raiz, manifesto) {
     const { dir, dentro } = pastaDasWorktreesPedida(raiz, manifesto);
     if (dentro)
         return null;
     const { local, motivo } = lerWorktreeLocal(raiz);
     if (local && local.dir === dir)
         return null;
-    const porque = local ? `a máquina confirmou ${local.dir}` : motivo ?? 'sem confirmação local';
-    return `worktree.dir-fora-da-raiz: o orkastery.yaml pede worktree.dir: ${JSON.stringify(manifesto.worktree.dir).slice(0, 200)}, ` +
-        `que leva a ${dir}, fora da raiz do projeto (pelo caminho real), e esta máquina não confirmou essa pasta (${porque}). ` +
-        '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: ${exports.COMANDO_CONFIRMAR_WORKTREE} (ou volte worktree.dir para dentro do projeto, ` +
-        'como .claude/worktrees).';
+    const pedido = JSON.stringify(manifesto.worktree.dir).slice(0, 200);
+    return (m) => m.worktree.dirForaDaRaiz(pedido, dir, local ? local.dir : null, motivo, exports.COMANDO_CONFIRMAR_WORKTREE);
 }
-/** Lança a recusa, quando houver. */
+/** Lança a recusa, quando houver, pelo catalogo: o CLI a remonta no locale do comando. */
 function exigirPastaDasWorktrees(raiz, manifesto) {
-    const recusa = recusaDePastaDasWorktrees(raiz, manifesto);
-    if (recusa)
-        throw new Error(recusa);
+    const montar = montadorDaRecusa(raiz, manifesto);
+    if (montar)
+        throw new locale_1.ErroDoCatalogo(montar);
 }
 /**
  * Grava a confirmação local da pasta que o manifesto pede hoje. Com `esperado`, ele precisa levar à

package/dist/worktree.js

@@ -65,6 +65,13 @@ const thread_1 = require("./thread");
 const util_1 = require("./util");
 const estado_thread_1 = require("./estado-thread");
 const procedencia_1 = require("./procedencia");
+const locale_1 = require("./locale");
+/**
+ * RM-061 (F3b, G4): o detalhe e a correcao que o resultado devolve nascem pelo catalogo, no locale ativo (pt-BR no
+ * escopo da gravacao), e ficam registrados para a impressao remonta-los; o que so vai ao ledger sai sempre em pt-BR.
+ */
+const tw = (montar) => (0, locale_1.textoDoCatalogo)((m) => montar(m.worktree));
+const gravado = () => (0, locale_1.msg)('pt-BR').worktree;
 /**
  * Diretorio canonico da worktree de uma thread, resolvido pelo `ork` na arvore principal: o mesmo que a criacao usa,
  * tambem quando o comando roda de dentro de outra worktree (P4 do ensaio da 0.5.0).
@@ -132,8 +139,8 @@ function garantirWorktree(carregado, id) {
                 branch,
                 base,
                 motivo: 'tree.blocked',
-                detalhe: `${dir} existe mas nao aparece em \`git worktree list\``,
-                correcao: `remova o diretorio ou registre a worktree; depois rode: ork worktree ensure ${id}`,
+                detalhe: tw((m) => m.naoRegistrada(dir)),
+                correcao: tw((m) => m.naoRegistradaCorrecao(id)),
             };
         }
         try {
@@ -141,7 +148,7 @@ function garantirWorktree(carregado, id) {
         }
         catch (e) {
             return { ok: false, criada: false, dir, branch, base, motivo: 'tree.blocked',
-                detalhe: e.message, correcao: `reconcilie o estado e rode ork worktree sync ${id}` };
+                detalhe: (0, locale_1.textoDoErro)(e), correcao: tw((m) => m.reconcilieOEstado(id)) };
         }
         if (thread.worktree !== dir) {
             thread.worktree = dir;
@@ -161,7 +168,7 @@ function garantirWorktree(carregado, id) {
             branch,
             base,
             motivo: null,
-            detalhe: 'a worktree da thread ja existe e o git a reconhece',
+            detalhe: tw((m) => m.jaExiste),
             correcao: '',
         };
     }
@@ -171,7 +178,7 @@ function garantirWorktree(carregado, id) {
         branchExistente: jaTemBranch ? branch : undefined,
     });
     thread.worktree = criada.dir;
-    thread.base = { branch: criada.branch, commit: thread.base.commit };
+    thread.base = { branch: criada.branch, commit: criada.commit };
     (0, thread_1.gravarThread)(raiz, thread);
     (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeGarantida, {
         dir: criada.dir,
@@ -181,16 +188,17 @@ function garantirWorktree(carregado, id) {
         branchReusada: jaTemBranch,
         fonte: 'git worktree list --porcelain',
     });
+    // RM-037 (defeito 2 de 19 e 20/10/2026): a worktree recriada nasce sem o que o git ignora, como a nova.
+    const dependencias = (0, thread_1.prepararDependenciasDaThread)(carregado, id, criada.dir);
     return {
         ok: true,
         criada: true,
+        dependencias,
         dir: criada.dir,
         branch: criada.branch,
         base,
         motivo: null,
-        detalhe: jaTemBranch
-            ? `worktree recriada sobre a branch ${criada.branch}, que ja existia`
-            : `worktree criada a partir de ${base}`,
+        detalhe: tw((m) => jaTemBranch ? m.recriadaSobreBranch(criada.branch) : m.criadaAPartirDe(base)),
         correcao: '',
     };
 }
@@ -259,8 +267,8 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             jaAtualizada: false,
             rebaseFeito: false,
             motivo: 'tree.blocked',
-            detalhe: `a thread ${id} nao tem worktree registrada no git`,
-            correcao: `crie a worktree com: ork worktree ensure ${id}`,
+            detalhe: tw((m) => m.semWorktree(id)),
+            correcao: tw((m) => m.semWorktreeCorrecao(id)),
         };
     }
     const limpa = arvoreLimpa(dir);
@@ -271,10 +279,8 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             jaAtualizada: false,
             rebaseFeito: false,
             motivo: 'tree.blocked',
-            detalhe: limpa === null
-                ? `${dir} nao respondeu a \`git status\``
-                : `${dir} tem alteracao nao commitada; rebase em arvore suja perde trabalho`,
-            correcao: `commite ou guarde as alteracoes em ${dir} e rode de novo: ork worktree sync ${id}`,
+            detalhe: tw((m) => limpa === null ? m.semStatus(dir) : m.arvoreSuja(dir)),
+            correcao: tw((m) => m.arvoreSujaCorrecao(dir, id)),
         };
     }
     try {
@@ -282,7 +288,7 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
     }
     catch (e) {
         return { ...vazio, ok: false, jaAtualizada: false, rebaseFeito: false,
-            motivo: 'tree.blocked', detalhe: e.message, correcao: 'reconcilie as duas cópias sem descartar evidências' };
+            motivo: 'tree.blocked', detalhe: (0, locale_1.textoDoErro)(e), correcao: tw((m) => m.reconcilieAsCopias) };
     }
     const refBase = (0, util_1.exec)('git', ['rev-parse', '--verify', base], raiz);
     if (!refBase.ok) {
@@ -292,8 +298,8 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             jaAtualizada: false,
             rebaseFeito: false,
             motivo: 'tree.blocked',
-            detalhe: `a base ${base} do manifesto nao existe neste repositorio`,
-            correcao: `corrija worktree.base_branch em ${carregado.caminho}`,
+            detalhe: tw((m) => m.baseInexistente(base)),
+            correcao: tw((m) => m.baseInexistenteCorrecao(carregado.caminho)),
         };
     }
     const shaBase = refBase.stdout.trim();
@@ -311,7 +317,7 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
                 shaAntes,
                 shaDepois: shaAntes,
                 rebaseFeito: false,
-                detalhe: 'a base ja era ancestral do HEAD da thread',
+                detalhe: gravado().jaEraAncestral,
             });
         }
         return {
@@ -323,7 +329,7 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             jaAtualizada: true,
             rebaseFeito: false,
             motivo: null,
-            detalhe: `a base ${base} ja esta incorporada: nada a sincronizar`,
+            detalhe: tw((m) => m.jaIncorporada(base)),
             correcao: '',
         };
     }
@@ -337,7 +343,7 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
         passos.push(`git reset --keep ${shaBase}`);
         if (opcoes.dryRun) {
             return { ...vazio, shaBase, shaAntes, shaDepois: shaAntes, ok: true, jaAtualizada: false, rebaseFeito: false, recriada: false,
-                motivo: null, detalhe: `a branch ${branch} nao tem commit proprio: o sync real a recriaria na base ${base} atual, sem rebase`,
+                motivo: null, detalhe: tw((m) => m.semCommitProprio(branch, base)),
                 correcao: '' };
         }
         let recriacao;
@@ -346,50 +352,48 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
         }
         catch (e) {
             return { ...vazio, shaBase, shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
-                motivo: 'tree.blocked', detalhe: e.message,
-                correcao: 'inspecione a cópia local e a fonte canônica preservadas antes de repetir o sync' };
+                motivo: 'tree.blocked', detalhe: (0, locale_1.textoDoErro)(e),
+                correcao: tw((m) => m.inspecioneAsCopias) };
         }
         const shaDepois = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], dir).stdout.trim();
         if (!recriacao.ok || shaDepois !== shaBase) {
             return { ...vazio, shaBase, shaAntes, shaDepois, ok: false, jaAtualizada: false, rebaseFeito: false, motivo: 'tree.blocked',
-                detalhe: `a recriacao da branch ${branch} na base falhou: ${(recriacao.stderr || recriacao.stdout).trim().split('\n').slice(-2).join(' | ')}`,
-                correcao: `confira a worktree ${dir} e rode de novo: ork worktree sync ${id}` };
+                detalhe: tw((m) => m.recriacaoFalhou(branch, (recriacao.stderr || recriacao.stdout).trim().split('\n').slice(-2).join(' | '))),
+                correcao: tw((m) => m.confiraAWorktree(dir, id)) };
         }
-        const detalhe = historia.semAncestral
-            ? `branch sem commit proprio recriada a partir da base ${base} atual; a base foi reescrita e nao tinha historia em comum com ela`
-            : `branch sem commit proprio recriada a partir da base ${base} atual`;
+        const detalhe = tw((m) => m.recriada(base, historia.semAncestral));
         (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, { dir, branch, base, shaBase, shaAntes, shaDepois,
-            rebaseFeito: false, recriada: true, semAncestral: historia.semAncestral, detalhe });
+            rebaseFeito: false, recriada: true, semAncestral: historia.semAncestral, detalhe: gravado().recriada(base, historia.semAncestral) });
         return { ...vazio, shaBase, shaAntes, shaDepois, ok: true, jaAtualizada: false, rebaseFeito: false, recriada: true,
             motivo: null, detalhe, correcao: '' };
     }
     if (historia.semAncestral) {
-        const onto = historia.pontoDePartida
+        const onto = (m) => historia.pontoDePartida
             ? `git -C ${dir} rebase --onto ${shaBase} ${historia.pontoDePartida}`
-            : `git -C ${dir} rebase --onto ${shaBase} <commit onde a branch da thread comecou>`;
-        const detalhe = `a base ${base} foi reescrita e nao tem historia em comum com a branch ${branch}, que tem ` +
-            `${historia.proprios ?? 'um numero desconhecido de'} commit(s) proprio(s): o rebase reaplicaria a historia antiga inteira`;
+            : `git -C ${dir} rebase --onto ${shaBase} ${m.ondeComecou}`;
+        const detalhe = tw((m) => m.semHistoriaComum(base, branch, historia.proprios));
         if (!opcoes.dryRun)
             (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, { dir, branch, base, shaBase, shaAntes,
-                rebaseFeito: false, motivo: 'tree.blocked', causa: 'base-reescrita', semAncestral: true, detalhe });
+                rebaseFeito: false, motivo: 'tree.blocked', causa: 'base-reescrita', semAncestral: true,
+                detalhe: gravado().semHistoriaComum(base, branch, historia.proprios) });
         return { ...vazio, shaBase, shaAntes, shaDepois: shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
-            motivo: 'tree.blocked', causa: 'base-reescrita', detalhe, correcao: `reaplique so os commits da thread sobre a base nova: ${onto}` };
+            motivo: 'tree.blocked', causa: 'base-reescrita', detalhe, correcao: tw((m) => m.reaplique(onto(m))) };
     }
     // RM-037 (fatia 3, defeito 3): com ancestral comum, o sync caia no `git rebase <base>` abaixo e
     // reaplicava tambem o que a reescrita tirou da base. O ponto de partida fora da base atual e o sinal.
     if (historia.baseReescrita) {
         const ponto = historia.pontoDePartida;
-        passos.push(`git merge-base --is-ancestor ${ponto.slice(0, 8)} ${shaBase.slice(0, 8)}   (falso: a base foi reescrita)`);
-        const detalhe = `a base ${base} foi reescrita: o ponto de partida ${ponto.slice(0, 8)} da branch ${branch} nao esta mais nela, ` +
-            `e o rebase comum reaplicaria ${historia.sairamDaBase ?? 'um numero desconhecido de'} commit(s) que sairam da base junto com ` +
-            `o(s) ${historia.proprios ?? '?'} da thread (git rev-list --count HEAD --not ${ponto.slice(0, 8)} ${shaBase.slice(0, 8)})`;
+        passos.push(tw((m) => m.passoBaseReescrita(ponto.slice(0, 8), shaBase.slice(0, 8))));
+        const contagem = `git rev-list --count HEAD --not ${ponto.slice(0, 8)} ${shaBase.slice(0, 8)}`;
+        const reescrita = (m) => m.baseReescrita(base, ponto.slice(0, 8), branch, historia.sairamDaBase, historia.proprios, contagem);
+        const detalhe = tw(reescrita);
         if (!opcoes.dryRun)
             (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, { dir, branch, base, shaBase, shaAntes,
                 rebaseFeito: false, motivo: 'tree.blocked', causa: 'base-reescrita', baseReescrita: true, pontoDePartida: ponto,
-                sairamDaBase: historia.sairamDaBase, proprios: historia.proprios, detalhe });
+                sairamDaBase: historia.sairamDaBase, proprios: historia.proprios, detalhe: reescrita(gravado()) });
         return { ...vazio, shaBase, shaAntes, shaDepois: shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
             motivo: 'tree.blocked', causa: 'base-reescrita', detalhe,
-            correcao: `reaplique so os commits da thread sobre a base nova: git -C ${dir} rebase --onto ${shaBase} ${ponto}` };
+            correcao: tw((m) => m.reaplique(`git -C ${dir} rebase --onto ${shaBase} ${ponto}`)) };
     }
     if (opcoes.dryRun) {
         passos.push(`git rebase ${shaBase}`);
@@ -402,7 +406,7 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             jaAtualizada: false,
             rebaseFeito: false,
             motivo: null,
-            detalhe: `a base ${base} avancou; o sync real faria o rebase acima`,
+            detalhe: tw((m) => m.rebaseAcima(base)),
             correcao: '',
         };
     }
@@ -417,8 +421,8 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
     }
     catch (e) {
         return { ...vazio, shaBase, shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
-            motivo: 'tree.blocked', detalhe: e.message,
-            correcao: 'inspecione a cópia local e a fonte canônica preservadas antes de repetir o sync' };
+            motivo: 'tree.blocked', detalhe: (0, locale_1.textoDoErro)(e),
+            correcao: tw((m) => m.inspecioneAsCopias) };
     }
     passos.push(`git rebase ${shaBase}`);
     if (!rebase.ok) {
@@ -443,9 +447,8 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             jaAtualizada: false,
             rebaseFeito: false,
             motivo: 'tree.blocked',
-            detalhe: `o rebase sobre ${base} conflitou e foi abortado: ${detalhe}`,
-            correcao: `resolva o conflito na worktree ${dir} (git rebase ${shaBase} e resolucao manual), ` +
-                `ou reduza a regiao da thread com um lease path:<glob> menor`,
+            detalhe: tw((m) => m.rebaseConflitou(base, detalhe)),
+            correcao: tw((m) => m.rebaseConflitouCorrecao(dir, shaBase)),
         };
     }
     const shaDepois = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], dir).stdout.trim();
@@ -457,7 +460,7 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
         shaAntes,
         shaDepois,
         rebaseFeito: true,
-        detalhe: `branch da thread rebasada sobre ${base}`,
+        detalhe: gravado().rebasada(base),
     });
     return {
         ...vazio,
@@ -468,7 +471,7 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
         jaAtualizada: false,
         rebaseFeito: true,
         motivo: null,
-        detalhe: `a base ${base} avancou e a branch ${branch} foi rebasada sobre ela`,
+        detalhe: tw((m) => m.rebasadaSobreEla(base, branch)),
         correcao: '',
     };
 }
@@ -486,11 +489,11 @@ function auditarWorktree(carregado, id) {
     const branchEsperada = branchDaWorktree(thread);
     const checks = [];
     checks.push(thread.worktree
-        ? { nome: 'registro', nivel: 'ok', detalhe: `thread.json aponta para ${thread.worktree}` }
+        ? { nome: 'registro', nivel: 'ok', detalhe: tw((m) => m.apontaPara(thread.worktree)) }
         : {
             nome: 'registro',
             nivel: 'fail',
-            detalhe: 'a thread nao tem worktree registrada no thread.json',
+            detalhe: tw((m) => m.semRegistroNoThread),
             correcao: `ork worktree ensure ${id}`,
         });
     const existe = fs.existsSync(dir);
@@ -499,25 +502,25 @@ function auditarWorktree(carregado, id) {
         : {
             nome: 'diretorio',
             nivel: 'fail',
-            detalhe: `${dir} nao existe no disco`,
+            detalhe: tw((m) => m.naoExisteNoDisco(dir)),
             correcao: `ork worktree ensure ${id}`,
         });
     const registro = worktreesDoGit(raiz).find((w) => w.dir === dir);
     checks.push(registro
-        ? { nome: 'git', nivel: 'ok', detalhe: 'aparece em `git worktree list --porcelain`' }
+        ? { nome: 'git', nivel: 'ok', detalhe: tw((m) => m.apareceNoGit) }
         : {
             nome: 'git',
             nivel: 'fail',
-            detalhe: `${dir} nao aparece em \`git worktree list\``,
+            detalhe: tw((m) => m.naoApareceNoGit(dir)),
             correcao: `git worktree prune && ork worktree ensure ${id}`,
         });
     if (registro) {
         checks.push(registro.branch === branchEsperada
-            ? { nome: 'branch', nivel: 'ok', detalhe: `${registro.branch} em check-out` }
+            ? { nome: 'branch', nivel: 'ok', detalhe: tw((m) => m.emCheckout(registro.branch)) }
             : {
                 nome: 'branch',
                 nivel: 'fail',
-                detalhe: `esperado ${branchEsperada}, encontrado "${registro.branch || '(HEAD solto)'}"`,
+                detalhe: tw((m) => m.branchErrada(branchEsperada, registro.branch)),
                 correcao: `git -C ${dir} switch ${branchEsperada}`,
             });
     }
@@ -528,20 +531,18 @@ function auditarWorktree(carregado, id) {
             (0, procedencia_1.exigirCwdLocal)(raiz, id, dir, 'thread');
         }
         catch (e) {
-            procedencia = e.message;
+            procedencia = (0, locale_1.textoDoErro)(e);
             checks.push({ nome: 'procedencia', nivel: 'fail', detalhe: procedencia, correcao: `ork worktree ensure ${id}` });
         }
     }
     if (existe && procedencia === null) {
         const limpa = arvoreLimpa(dir);
         checks.push(limpa === true
-            ? { nome: 'arvore', nivel: 'ok', detalhe: 'sem alteracao nao commitada' }
+            ? { nome: 'arvore', nivel: 'ok', detalhe: tw((m) => m.arvoreLimpa) }
             : {
                 nome: 'arvore',
                 nivel: limpa === null ? 'fail' : 'warn',
-                detalhe: limpa === null
-                    ? '`git status` nao respondeu neste diretorio'
-                    : 'ha alteracao nao commitada na worktree',
+                detalhe: tw((m) => limpa === null ? m.statusSemResposta : m.alteracaoNaWorktree),
                 correcao: `git -C ${dir} status`,
             });
         const base = manifesto.worktree.base_branch;
@@ -550,11 +551,11 @@ function auditarWorktree(carregado, id) {
             const shaBase = refBase.stdout.trim();
             const incorporada = (0, util_1.exec)('git', ['merge-base', '--is-ancestor', shaBase, 'HEAD'], dir).ok;
             checks.push(incorporada
-                ? { nome: 'base', nivel: 'ok', detalhe: `${base} @ ${shaBase.slice(0, 8)} ja incorporada` }
+                ? { nome: 'base', nivel: 'ok', detalhe: tw((m) => m.baseIncorporada(base, shaBase.slice(0, 8))) }
                 : {
                     nome: 'base',
                     nivel: 'fail',
-                    detalhe: `a base ${base} avancou para ${shaBase.slice(0, 8)} e nao esta na branch da thread`,
+                    detalhe: tw((m) => m.baseAdiante(base, shaBase.slice(0, 8))),
                     correcao: `ork worktree sync ${id}`,
                 });
         }
@@ -565,13 +566,13 @@ function auditarWorktree(carregado, id) {
         ? {
             nome: 'artefatos',
             nivel: 'fail',
-            detalhe: `os artefatos da thread estao DENTRO da worktree (${dirArtefatos})`,
-            correcao: 'os artefatos da thread vivem em .orkastery/threads/<id>, fora da arvore',
+            detalhe: tw((m) => m.artefatosDentro(dirArtefatos)),
+            correcao: tw((m) => m.artefatosDentroCorrecao),
         }
         : {
             nome: 'artefatos',
             nivel: 'ok',
-            detalhe: `${path.relative(raiz, dirArtefatos)} fica fora da worktree`,
+            detalhe: tw((m) => m.artefatosFora(path.relative(raiz, dirArtefatos))),
         });
     if (existe)
         checks.push((0, estado_thread_1.auditarEstado)(raiz, id, dir));
@@ -587,21 +588,16 @@ function auditarWorktree(carregado, id) {
 }
 /** Texto de `ork worktree audit`. */
 function textoDoAudit(id, r) {
-    const linhas = [
-        `Auditoria da worktree da thread ${id}`,
-        `  dir     ${r.dir}`,
-        `  branch  ${r.branch}`,
-        '',
-    ];
+    // RM-061 (F3b): a moldura pelo catalogo; o nome do check (dado do ledger) traduzido so aqui, e o detalhe remontado.
+    const m = (0, locale_1.msg)().worktree;
+    const linhas = [m.auditoria(id), m.linhaDir(r.dir), m.linhaBranch(r.branch), ''];
     for (const c of r.checks) {
-        linhas.push(`  ${(0, util_1.simbolo)(c.nivel)} ${c.nome.padEnd(11)} ${c.detalhe}`);
+        linhas.push(`  ${(0, util_1.simbolo)(c.nivel)} ${m.nomeDoCheck(c.nome).padEnd(11)} ${(0, locale_1.remontar)(c.detalhe)}`);
         if (c.nivel !== 'ok' && c.correcao)
-            linhas.push(`         correcao: ${c.correcao}`);
+            linhas.push(m.correcaoDoCheck((0, locale_1.remontar)(c.correcao)));
     }
     linhas.push('');
-    linhas.push(r.ok
-        ? '  worktree consistente: o git confirma cada item acima.'
-        : `  ${r.divergencias} divergencia(s) encontrada(s) no proprio git.`);
+    linhas.push(r.ok ? m.consistente : m.divergencias(r.divergencias));
     return linhas.join('\n');
 }
 /** Solta os leases de escrita que a thread ainda segurava. */
@@ -640,7 +636,7 @@ function liberarWorktree(carregado, id, opcoes = {}) {
             branch,
             removida: false,
             leasesLiberados: soltos,
-            detalhe: 'o diretorio ja nao existia; o registro foi limpo',
+            detalhe: gravado().jaNaoExistia,
         });
         return {
             ok: true,
@@ -649,7 +645,7 @@ function liberarWorktree(carregado, id, opcoes = {}) {
             branch,
             leasesLiberados: soltos,
             motivo: null,
-            detalhe: 'o diretorio ja nao existia; registro limpo e `git worktree prune` rodado',
+            detalhe: tw((m) => m.jaNaoExistiaImpresso),
             correcao: '',
         };
     }
@@ -659,7 +655,7 @@ function liberarWorktree(carregado, id, opcoes = {}) {
     }
     catch (e) {
         return { ok: false, removida: false, dir, branch, leasesLiberados: [], motivo: 'tree.blocked',
-            detalhe: e.message, correcao: `confira o diretorio e o thread.json da thread ${id}` };
+            detalhe: (0, locale_1.textoDoErro)(e), correcao: tw((m) => m.confiraODiretorio(id)) };
     }
     const limpa = arvoreLimpa(dir);
     if (limpa === false && !opcoes.forcar) {
@@ -670,8 +666,8 @@ function liberarWorktree(carregado, id, opcoes = {}) {
             branch,
             leasesLiberados: [],
             motivo: 'tree.blocked',
-            detalhe: `${dir} tem alteracao nao commitada`,
-            correcao: `commite o que interessa em ${dir}, ou repita com --forcar para descartar`,
+            detalhe: tw((m) => m.releaseArvoreSuja(dir)),
+            correcao: tw((m) => m.releaseArvoreSujaCorrecao(dir)),
         };
     }
     const argumentos = ['worktree', 'remove', dir];
@@ -686,8 +682,8 @@ function liberarWorktree(carregado, id, opcoes = {}) {
             branch,
             leasesLiberados: [],
             motivo: 'tree.blocked',
-            detalhe: `git worktree remove falhou: ${(r.stderr || r.stdout).trim()}`,
-            correcao: `rode \`git worktree remove ${dir}\` na mao e confira \`git worktree list\``,
+            detalhe: tw((m) => m.removeFalhou((r.stderr || r.stdout).trim())),
+            correcao: tw((m) => m.removeFalhouCorrecao(dir)),
         };
     }
     (0, util_1.exec)('git', ['worktree', 'prune'], raiz);
@@ -700,7 +696,7 @@ function liberarWorktree(carregado, id, opcoes = {}) {
             branch,
             leasesLiberados: [],
             motivo: 'tree.blocked',
-            detalhe: `${dir} continua em \`git worktree list\` depois do remove`,
+            detalhe: tw((m) => m.continuaNaLista(dir)),
             correcao: 'git worktree prune && git worktree list',
         };
     }
@@ -722,7 +718,7 @@ function liberarWorktree(carregado, id, opcoes = {}) {
         branch,
         leasesLiberados: soltos,
         motivo: null,
-        detalhe: `worktree removida; a branch ${branch} continua no repositorio`,
+        detalhe: tw((m) => m.removida(branch)),
         correcao: '',
     };
 }

package/eval/casos/check-quality.json

@@ -98,6 +98,83 @@
           "porque": "a regra dos motivos tipados"
         }
       ]
+    },
+    {
+      "id": "check-quality/zero-bloqueadores-com-scan",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "O scan do CHECK tem achado `new` do laco sem veredito de triagem e um achado `warn`.",
+      "esperado": "Nao ha zero bloqueadores: falta o veredito. O `warn` vai ao eixo certo como aviso registrado.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "nenhum achado `new` do laco sem veredito resolvido",
+          "porque": "a definicao de zero bloqueadores com o scan"
+        },
+        {
+          "tipo": "contem",
+          "valor": "aviso registrado",
+          "porque": "o warn nao e descartado"
+        }
+      ]
+    },
+    {
+      "id": "check-quality/inconclusivo-pelo-gate-da-pausa",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "O auditor deu inconclusivo a um achado `new` do laco e a sessao do CHECK tenta abrir o pedido ao dono.",
+      "esperado": "O pedido sai depois da sessao, pelo `ork gate request` da pausa do bloco; de dentro da sessao ou com motivo livre ele recusa, e sem a pausa o veredito e BLOQUEADO.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Inconclusivo nao abre o pedido de dentro da sessao do CHECK",
+          "porque": "a recusa medida na prova ponta a ponta"
+        },
+        {
+          "tipo": "contem",
+          "valor": "`ork gate request <thread> --formato telegram`",
+          "porque": "o comando que abre a pausa ao dono"
+        },
+        {
+          "tipo": "contem",
+          "valor": "`modo nao preve pausa humana nesta fase`",
+          "porque": "o modo sem pausa no CHECK"
+        },
+        {
+          "tipo": "contem",
+          "valor": "quem conduz aponta ao dono a pergunta do parecer",
+          "porque": "o pedido do gate leva so a pergunta generica"
+        },
+        {
+          "tipo": "contem",
+          "valor": "A resposta do dono vira claim do CHECK",
+          "porque": "a resposta chega ao GO-FIX pelo mesmo caminho"
+        },
+        {
+          "tipo": "contem",
+          "valor": "#Look e #Ork tambem pausavam no CHECK, mas estao aposentados (I-43)",
+          "porque": "a lista de modos com a pausa"
+        }
+      ]
+    },
+    {
+      "id": "check-quality/veredito-por-achado-no-fix-open",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "O CHECK reprovou pelo scan com um achado real e um falso positivo triados.",
+      "esperado": "O `ork fix open` abre uma correcao por claim do CHECK, tipo B para o real e tipo A para o falso positivo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "`ork fix open <thread>` reexecuta o verify e abre uma correcao por claim reprovada",
+          "porque": "o mecanismo real do veredito por achado"
+        },
+        {
+          "tipo": "contem",
+          "valor": "tipo A para o falso positivo (`claims.unverifiable`)",
+          "porque": "o tipo que a claim sem comando produz"
+        }
+      ]
     }
   ]
 }