@orkastery/cli 0.5.1 → 0.5.6

package/dist/retry.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.POLITICA_DE_RETRY = exports.ESCADA_DE_ESFORCO = void 0;
+exports.TETO_DO_PROMPT_GRAVADO = exports.POLITICA_DE_RETRY = exports.ESCADA_DE_ESFORCO = void 0;
 exports.proximoEsforco = proximoEsforco;
 exports.politicaDoMotivo = politicaDoMotivo;
 exports.podeReexecutar = podeReexecutar;
@@ -45,6 +45,8 @@ exports.estadoTerminalDeRetry = estadoTerminalDeRetry;
 exports.planejarRetry = planejarRetry;
 exports.escalarEsforco = escalarEsforco;
 exports.redespachar = redespachar;
+exports.localizarPromptGravado = localizarPromptGravado;
+exports.despachoParaRedespachar = despachoParaRedespachar;
 exports.playbookDaRetomada = playbookDaRetomada;
 exports.retomarPedido = retomarPedido;
 exports.retomarFila = retomarFila;
@@ -86,6 +88,8 @@ const runtimes_1 = require("./runtimes");
 const setup_1 = require("./setup");
 const gates_1 = require("./gates");
 const ledger_1 = require("./ledger");
+const estado_thread_1 = require("./estado-thread");
+const vida_da_thread_1 = require("./vida-da-thread");
 const phase_1 = require("./phase");
 const runtime_context_1 = require("./runtime-context");
 const slug_1 = require("./slug");
@@ -97,12 +101,19 @@ const modos_1 = require("./modos");
 const thread_1 = require("./thread");
 const tokens_1 = require("./tokens");
 const util_1 = require("./util");
+const impedimento_1 = require("./impedimento");
 const worktree_1 = require("./worktree");
 const delegation_1 = require("./delegation");
 const gates_2 = require("./gates");
 const horario_1 = require("./horario");
 const conducao_1 = require("./conducao");
 const conducao_texto_1 = require("./conducao-texto");
+const procedencia_1 = require("./procedencia");
+const postura_local_1 = require("./postura-local");
+const locale_1 = require("./locale");
+const locale_retry_1 = require("./locale-retry");
+/** RM-061 (F2b, D3): `porque` e `correcao` de cada motivo tem a fonte no catalogo pt-BR; o `--json` nao muda. */
+const TEXTOS_DA_POLITICA = locale_retry_1.RETRY_PT_BR.politica;
 /**
  * Escada de esforco da 2a tentativa em diante.
  *
@@ -128,29 +139,25 @@ exports.POLITICA_DE_RETRY = {
         motivo: 'artifact.missing',
         acao: 'corrigir-dirigido',
         automatica: true,
-        porque: 'o artefato exigido pela fase nao existe: a fase precisa de spec dirigida do que gravar, nao de repeticao cega do mesmo prompt',
-        correcao: 'ork fix open <thread> abre a rodada com a spec exata',
+        ...TEXTOS_DA_POLITICA['artifact.missing'],
     },
     'claims.failed': {
         motivo: 'claims.failed',
         acao: 'corrigir-dirigido',
         automatica: true,
-        porque: 'a alegacao reprovou na reexecucao no HEAD real: reexecutar a fase igual reproduz a mesma mentira; o que resolve e GO-FIX com a claim e o comando exatos',
-        correcao: 'ork fix open <thread> e depois ork fix reverify <thread>',
+        ...TEXTOS_DA_POLITICA['claims.failed'],
     },
     'claims.unverifiable': {
         motivo: 'claims.unverifiable',
         acao: 'corrigir-dirigido',
         automatica: true,
-        porque: 'alegacao sem comando de verificacao vira correcao tipo A: anexar o comando (ou retirar a alegacao com motivo) e uma linha, nao um GO inteiro',
-        correcao: 'ork claims verificar <thread> <claim> --comando "<comando>"',
+        ...TEXTOS_DA_POLITICA['claims.unverifiable'],
     },
     'policy.violation': {
         motivo: 'policy.violation',
         acao: 'escalar-humano',
         automatica: false,
-        porque: 'policy com severidade block reprova em qualquer modo: reexecutar sozinho seria a maquina revogando a policy do manifesto',
-        correcao: 'corrija a violacao no pedido/manifesto; policy block nao se resolve por repeticao',
+        ...TEXTOS_DA_POLITICA['policy.violation'],
     },
     'runtime.autoconferencia': {
         motivo: 'runtime.autoconferencia',
@@ -160,69 +167,66 @@ exports.POLITICA_DE_RETRY = {
         // decide em que runtime o CHECK roda e quem conduz a thread.
         acao: 'escalar-humano',
         automatica: false,
-        porque: 'repetir o despacho no MESMO runtime daria o mesmo resultado: o que falta nao e tentativa, e um validador que nao seja quem executou. Escolher o outro runtime e decisao de conducao, nao retry',
-        correcao: 'despache o CHECK em outro runtime (`ork phase run <thread> CHECK --runtime <outro>`), ou tire a exigencia de validacao cruzada da thread se ela nao se justifica',
+        ...TEXTOS_DA_POLITICA['runtime.autoconferencia'],
+    },
+    // RM-056 (D1): o perfil pedido nao existe ou e de outro runtime. Quem corrige e quem pediu.
+    'runtime.profile-invalid': {
+        motivo: 'runtime.profile-invalid',
+        acao: 'escalar-humano',
+        automatica: false,
+        ...TEXTOS_DA_POLITICA['runtime.profile-invalid'],
     },
     'cost.violation': {
         motivo: 'cost.violation',
         acao: 'sem-retry',
         automatica: false,
-        porque: 'violacao de CUSTO nunca recebe retry automatico: cada reexecucao gastaria de novo pelo provider pago (subscription-only e regra de codigo, nao lembrete)',
-        correcao: 'tire do ambiente a variavel que redireciona o despacho e rode a fase de novo a mao, com o gasto sob os olhos de um humano',
+        ...TEXTOS_DA_POLITICA['cost.violation'],
     },
     'verify.regression': {
         motivo: 'verify.regression',
         acao: 'corrigir-dirigido',
         automatica: true,
-        porque: 'o comando passava na baseline e falha agora: o defeito e desta thread e tem alvo conhecido, entao ele vira spec de GO-FIX tipo B',
-        correcao: 'ork fix open <thread> (a reexecucao seguinte e completa)',
+        ...TEXTOS_DA_POLITICA['verify.regression'],
     },
     'verify.failed': {
         motivo: 'verify.failed',
         acao: 'corrigir-dirigido',
         automatica: true,
-        porque: 'o comando falha sem baseline para separar regressao de divida: a correcao dirigida conserta ou grava a baseline, mas nao chuta de quem e a culpa',
-        correcao: 'ork fix open <thread>, ou ork verify <thread> --baseline antes do proximo GO',
+        ...TEXTOS_DA_POLITICA['verify.failed'],
     },
     'verify.timeout': {
         motivo: 'verify.timeout',
         acao: 'reexecutar',
         automatica: true,
-        porque: 'o prazo estourou antes de o comando terminar: a prova nao chegou ao fim, e carga de maquina nao e defeito. A reexecucao e completa, e o limite de escalacao do manifesto impede repetir para sempre',
-        correcao: 'ork verify <thread> de novo; se estourar sempre, suba verify.timeout_ms no manifesto ou divida o comando',
+        ...TEXTOS_DA_POLITICA['verify.timeout'],
     },
     'verify.sem-veredito': {
         motivo: 'verify.sem-veredito',
         acao: 'reexecutar',
         automatica: true,
-        porque: 'um comando nao chegou a rodar ou o produto mudou no meio da rodada: nao ha veredito sobre ele, e a prova certa e rodar de novo, inteira',
-        correcao: 'ork verify <thread> de novo, sem editar a worktree durante a rodada',
+        ...TEXTOS_DA_POLITICA['verify.sem-veredito'],
     },
     'ci.failed': {
         motivo: 'ci.failed',
         acao: 'escalar-humano',
         automatica: false,
-        porque: 'o recibo pertence ao provedor e ao SHA candidato: repetir uma fase não cria nem altera legitimamente esse resultado',
-        correcao: 'publique a candidata, aguarde o check obrigatório e repita o SHIP; se reprovou, corrija a causa registrada no runner',
+        ...TEXTOS_DA_POLITICA['ci.failed'],
     },
     'runtime.unavailable': {
         motivo: 'runtime.unavailable',
         acao: 'reexecutar',
         automatica: true,
-        porque: 'falha de infraestrutura no despacho nao e falha de conteudo: o MESMO prompt, com o mesmo sha256, e redespachado sem alterar uma virgula',
-        correcao: 'ork retry run <thread> redespacha o prompt ja gravado em disco',
+        ...TEXTOS_DA_POLITICA['runtime.unavailable'],
     },
     'runtime.silencio': {
         motivo: 'runtime.silencio', acao: 'reexecutar', automatica: true,
-        porque: 'fase sem heartbeat: retomar o despacho original com hash conferido e limite de tentativas',
-        correcao: 'ork retry run <thread> --motivo runtime.silencio',
+        ...TEXTOS_DA_POLITICA['runtime.silencio'],
     },
     'runtime.rate-limited': {
         motivo: 'runtime.rate-limited',
         acao: 'esperar-janela',
         automatica: true,
-        porque: 'o limite de uso tem HORA de volta: a fase entra na fila duravel e e retomada na janela seguinte, sem humano no meio e sem gastar por fora da assinatura',
-        correcao: 'ork retry list mostra a fila; ork retry resume retoma o que ja liberou',
+        ...TEXTOS_DA_POLITICA['runtime.rate-limited'],
     },
     // I-33 (D5, D11): a falha e da CONTA. O perfil sai do rodizio e o MESMO prompt vai ao proximo
     // perfil ativo, depois ao runtime de fallback do bloco, e so por ultimo a fila duravel. A
@@ -232,15 +236,13 @@ exports.POLITICA_DE_RETRY = {
         motivo: 'runtime.quota-exhausted',
         acao: 'reexecutar',
         automatica: true,
-        porque: 'a cota ou os creditos da CONTA acabaram, nao a infraestrutura: o perfil sai do rodizio ate o prazo e o MESMO prompt, com o mesmo sha256, segue no proximo perfil, no runtime de fallback ou na fila ate o menor prazo',
-        correcao: 'ork accounts list mostra o perfil esgotado; ork retry run <thread> rotaciona o prompt ja gravado',
+        ...TEXTOS_DA_POLITICA['runtime.quota-exhausted'],
     },
     'runtime.auth-missing': {
         motivo: 'runtime.auth-missing',
         acao: 'reexecutar',
         automatica: true,
-        porque: 'a conta do runtime perdeu a autenticacao: o perfil nunca mais recebe despacho ate o login ser refeito pelo proprio CLI, e o MESMO prompt segue no proximo perfil ou no runtime de fallback',
-        correcao: 'ork accounts check confere o login de cada perfil; ork retry run <thread> rotaciona o prompt ja gravado',
+        ...TEXTOS_DA_POLITICA['runtime.auth-missing'],
     },
     // RM-037 (defeitosdeco D-6): o modelo e que falta, nao a conta. Repetir o mesmo modelo na mesma conta
     // so repete a recusa; o perfil continua no rodizio para os outros modelos.
@@ -248,22 +250,39 @@ exports.POLITICA_DE_RETRY = {
         motivo: 'runtime.model-unavailable',
         acao: 'reexecutar',
         automatica: true,
-        porque: 'o modelo pedido nao existe ou a conta nao tem acesso a ele: o MESMO prompt, com o mesmo sha256, segue no proximo perfil do mesmo runtime com o mesmo modelo e depois no fallback do bloco, nunca de novo no par que ja recusou',
-        correcao: 'ork retry run <thread> troca o destino; sem destino, ork setup <modo> --bloco N --model <modelo acessivel> ou --fallback runtime:modelo',
+        ...TEXTOS_DA_POLITICA['runtime.model-unavailable'],
+    },
+    // RM-055: so o dono destrava, no terminal. O retry nao repete o despacho as cegas: confere antes se o
+    // impedimento saiu (a confianca do diretorio tem prova local) e, sem prova, deixa o runtime decidir.
+    'runtime.workspace-untrusted': {
+        motivo: 'runtime.workspace-untrusted',
+        acao: 'reexecutar',
+        automatica: true,
+        ...TEXTOS_DA_POLITICA['runtime.workspace-untrusted'],
+    },
+    'runtime.consent-pending': {
+        motivo: 'runtime.consent-pending',
+        acao: 'reexecutar',
+        automatica: true,
+        ...TEXTOS_DA_POLITICA['runtime.consent-pending'],
     },
     'tree.blocked': {
         motivo: 'tree.blocked',
         acao: 'sincronizar-worktree',
         automatica: true,
-        porque: 'a arvore de destino andou por baixo da thread: rebasar a worktree contra a base e o passo que desbloqueia, e reexecutar antes disso so repete o conflito',
-        correcao: 'ork worktree sync <thread> e so entao repetir o passo',
+        ...TEXTOS_DA_POLITICA['tree.blocked'],
+    },
+    'lease.resume-unavailable': {
+        motivo: 'lease.resume-unavailable',
+        acao: 'escalar-humano',
+        automatica: false,
+        ...TEXTOS_DA_POLITICA['lease.resume-unavailable'],
     },
     'lease.busy': {
         motivo: 'lease.busy',
         acao: 'reexecutar',
         automatica: true,
-        porque: 'o lease e de outra thread e vai ser liberado: a fila ja serializa, entao a acao e tentar de novo quando chegar a vez, nunca furar a fila',
-        correcao: 'ork lease list mostra a fila; a vez chega sem ninguem forcar',
+        ...TEXTOS_DA_POLITICA['lease.busy'],
     },
     // I-36 (T6): a vez chega quando a conducao atual terminar. Redespachar agora so recebe a mesma recusa,
     // e passar na frente de quem conduz e exatamente o incidente de 19/09/2026.
@@ -271,8 +290,7 @@ exports.POLITICA_DE_RETRY = {
         motivo: 'conducao.em-andamento',
         acao: 'esperar-janela',
         automatica: true,
-        porque: 'outra conducao executa na mesma worktree agora: a vez chega quando ela terminar, e furar a fila e o incidente de 19/09/2026',
-        correcao: 'ork conducao status <thread> mostra quem conduz; repita o pedido com --esperar <min> para seguir sozinho quando liberar',
+        ...TEXTOS_DA_POLITICA['conducao.em-andamento'],
     },
     // I-41 (D10): formato e defeito de quem escreveu o pedido, e a spec dirigida conserta.
     // Escalar isto para o dono seria pedir que ele revise a sintaxe do robo.
@@ -280,15 +298,13 @@ exports.POLITICA_DE_RETRY = {
         motivo: 'hitl.formato',
         acao: 'corrigir-dirigido',
         automatica: true,
-        porque: 'o pedido HITL saiu fora do formato obrigatorio: quem errou foi o emissor, e a correcao e reemitir com alternativas rotuladas, consequencia por alternativa e exatamente uma recomendada com o porque',
-        correcao: 'ork fix open <thread> abre a rodada com a spec exata do formato',
+        ...TEXTOS_DA_POLITICA['hitl.formato'],
     },
     'human.pending': {
         motivo: 'human.pending',
         acao: 'escalar-humano',
         automatica: false,
-        porque: 'nao e reprovacao de verdade, e espera de autorizacao: automatizar a espera seria a maquina se autorizando',
-        correcao: 'ork gate request <thread>',
+        ...TEXTOS_DA_POLITICA['human.pending'],
     },
 };
 /** A politica de um motivo tipado. */
@@ -337,7 +353,8 @@ function ultimaReprovacao(raiz, threadId) {
  * planejou: planejar nao gasta janela nem toca no repositorio.
  */
 function tentativasFeitas(raiz, threadId, fase, motivo) {
-    return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId)).filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.retryTentado && e.fase === fase && e.motivo === motivo).length;
+    // RM-055 (continuacao, D2): a recusa pelo impedimento do dono fica no ledger com `conta: false` e nao conta.
+    return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId)).filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.retryTentado && e.fase === fase && e.motivo === motivo && e.conta !== false).length;
 }
 /** O bloco de loop desta fase pausa para o humano neste modo? */
 function blocoPausa(thread, fase) {
@@ -365,7 +382,7 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
             modo: thread.modo,
             fase: opcoes.fase ?? thread.faseAtual,
             motivo: null,
-            detalhe: 'nenhum gate reprovado no ledger desta thread',
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.semReprovacao),
             politica: null,
             acao: 'sem-retry',
             tentativas: 0,
@@ -374,7 +391,7 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
             effortAnterior: effortBase,
             automatica: false,
             bloqueio: 'gate.sem-reprovacao',
-            razao: 'nao ha o que repetir: o ledger da thread nao tem reprovacao tipada pendente',
+            razao: (0, locale_1.textoDoCatalogo)((m) => m.retry.nadaARepetir),
         };
     }
     const fase = opcoes.fase ?? (evento ? faseDoEvento(evento, thread) : thread.faseAtual);
@@ -397,7 +414,7 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
             effortAnterior: effortBase,
             automatica: false,
             bloqueio: 'politica.nao-automatica',
-            razao: politica.porque,
+            razao: (0, locale_1.textoDoCatalogo)((m) => m.retry.politica[motivo].porque),
         };
     }
     // Limite de escalacao: pausa QUALQUER modo, inclusive #Auto.
@@ -416,8 +433,7 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
             effortAnterior: effortBase,
             automatica: false,
             bloqueio: 'escalacao.limite',
-            razao: `${tentativas} tentativa(s) automatica(s) por ${motivo} em ${fase}, no limite de ${limite} ` +
-                'do manifesto: escalacao tipada pausa qualquer modo, inclusive #Auto',
+            razao: (0, locale_1.textoDoCatalogo)((m) => m.retry.limiteDeEscalacao(tentativas, motivo, fase, limite)),
         };
     }
     // Da 2a tentativa em diante o esforco sobe um degrau, quando o manifesto permite.
@@ -433,9 +449,10 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
     const autorizado = delegacao.permitida || (0, gates_2.aprovacoesHumanas)(raiz, threadId).some(e => e.fase === fase && e.autorizadoPor === opcoes.autorizadoPor);
     let bloqueio = null;
     let automatica = politica.automatica;
-    let razao = politica.porque;
-    if (delegacao.permitida && politica.automatica)
-        razao += `; ${delegacao.razao}; delegado ${delegacao.delegado}; evidência ${delegacao.evidencia}`;
+    let razao = (0, locale_1.textoDoCatalogo)((m) => m.retry.politica[motivo].porque);
+    if (delegacao.permitida && politica.automatica) {
+        razao = (0, locale_1.textoDoCatalogo)((m) => m.retry.comDelegacao(m.retry.politica[motivo].porque, delegacao.razao, String(delegacao.delegado), String(delegacao.evidencia)));
+    }
     if (!politica.automatica) {
         automatica = false;
         bloqueio = 'politica.nao-automatica';
@@ -445,10 +462,8 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
         // a acao fica planejada e nao executada. `#Maestro` e `#Auto` nao caem neste ramo.
         automatica = false;
         bloqueio = 'modo.bloco-pausa';
-        razao =
-            `o bloco ${(0, thread_1.blocoDaThread)(thread, fase).fases.join('-')} pausa neste modo ` +
-                `(${(0, thread_1.blocoDaThread)(thread, fase).pausaSobre}): a acao ${acao} espera autorizacao humana. ` +
-                'O modo afrouxa a pausa, nunca a verificacao.';
+        const bloco = (0, thread_1.blocoDaThread)(thread, fase);
+        razao = (0, locale_1.textoDoCatalogo)((m) => m.retry.blocoPausa(bloco.fases.join('-'), m.thread.pausaSobre(bloco.pausaSobre), acao));
     }
     if (motivo === 'runtime.silencio') {
         const despacho = ultimoDespachoFalho(raiz, threadId, fase, true);
@@ -456,7 +471,7 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
         if (!prova || prova.sessionId !== despacho?.sessionId || !estadoTerminalDeRetry(prova.estado)) {
             automatica = false;
             bloqueio = 'politica.nao-automatica';
-            razao = 'runtime.silencio exige prova terminal atual da mesma sessao; ausencia ou silencio nao provam morte';
+            razao = (0, locale_1.textoDoCatalogo)((m) => m.retry.silencioSemProva);
         }
     }
     return {
@@ -502,24 +517,92 @@ function redespachar(carregado, thread, fase, promptRelativo, sha, opcoes = {})
         retida.devolver();
     }
 }
+/**
+ * RM-063 (F3): onde esta o prompt gravado. O ledger guarda o caminho relativo a raiz de codigo de quem despachou:
+ * da worktree, ele sai `../../../.orkastery/threads/...` (a K7 de 12/10/2026), e lido do checkout principal aponta
+ * para fora do projeto. O arquivo certo e o que tem o MESMO sha256: absoluto, relativo a raiz de codigo, a raiz do
+ * estado ou a pasta de prompts da thread. Sem nenhum com o sha, vale o primeiro que existe (a recusa diz que o prompt
+ * mudou); sem nenhum arquivo comum dentro do projeto, `null` (a recusa diz que sumiu).
+ */
+function localizarPromptGravado(raiz, threadId, promptPath, sha) {
+    const candidatos = path.isAbsolute(promptPath) ? [promptPath] : [path.join(raiz, promptPath)];
+    try {
+        candidatos.push(path.join((0, estado_thread_1.raizDoEstado)(raiz), promptPath));
+    }
+    catch { /* raiz sem estado legivel */ }
+    candidatos.push(path.join((0, thread_1.dirThread)(raiz, threadId), 'prompts', path.basename(promptPath)));
+    let thread = null;
+    try {
+        const t = (0, thread_1.lerThread)(raiz, threadId);
+        thread = { id: t.id, worktree: t.worktree };
+    }
+    catch {
+        thread = null;
+    }
+    // O ponteiro vem do estado: so arquivo comum, de tamanho de prompt, dentro do projeto ou da worktree da thread (RM-047).
+    const legivel = (c) => {
+        try {
+            const st = fs.lstatSync(c);
+            return st.isFile() && st.size <= exports.TETO_DO_PROMPT_GRAVADO && (0, procedencia_1.caminhoContidoOuNulo)(raiz, thread, c) !== null;
+        }
+        catch {
+            return false;
+        }
+    };
+    const existentes = [...new Set(candidatos.map((c) => path.resolve(c)))].filter(legivel);
+    for (const c of existentes) {
+        try {
+            if ((0, phase_1.hashDoPrompt)(fs.readFileSync(c, 'utf8')) === sha)
+                return c;
+        }
+        catch { /* ilegivel: tenta o proximo */ }
+    }
+    return existentes[0] ?? null;
+}
+/** Um prompt de fase tem dezenas de KB; acima disto o ponteiro do estado nao e um prompt gravado pelo ork. */
+exports.TETO_DO_PROMPT_GRAVADO = 4 * 1024 * 1024;
+/**
+ * RM-063 (F3): o despacho cujo prompt o `reexecutar` devolve ao runtime. Primeiro o despacho da sessao do gate (a
+ * sessao que morreu depois de despachada, como a K7 de 12/10/2026, nao deixa `phase_dispatch_failed`), depois o
+ * proprio gate quando ele carrega o prompt, e por fim a tentativa mais recente da fase com prompt gravado:
+ * `phase_dispatch_failed` ou `phase_prompt_recorded` (e o `phase_dispatch`, no silencio do runtime).
+ */
+function despachoParaRedespachar(eventos, fase, gate, silencio = false) {
+    const comPrompt = (e) => !!e && typeof e.promptPath === 'string' && typeof e.promptSha256 === 'string';
+    if (gate && typeof gate.sessionId === 'string') {
+        const daSessao = eventos.filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada && e.sessionId === gate.sessionId).at(-1);
+        if (comPrompt(daSessao))
+            return daSessao;
+    }
+    if (comPrompt(gate))
+        return gate;
+    for (let i = eventos.length - 1; i >= 0; i--) {
+        const e = eventos[i];
+        if (e.fase !== fase || !comPrompt(e))
+            continue;
+        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou || e.tipo === ledger_1.TIPOS_DE_EVENTO.promptGravado ||
+            (silencio && e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada))
+            return e;
+    }
+    return null;
+}
 function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes = {}, 
 /** A tomada que a primeira passada reteve para a baseline; com ela, esta e a repeticao. */
 tomadaPrevia) {
     const { raiz, manifesto } = carregado;
-    const absoluto = path.isAbsolute(promptRelativo)
-        ? promptRelativo
-        : path.join(raiz, promptRelativo);
+    const achado = localizarPromptGravado(raiz, thread.id, promptRelativo, sha);
+    const absoluto = achado ?? '';
     const slug = opcoes.slug ?? (0, phase_1.slugDaSessao)(thread, fase);
     const vazio = { slug, sessionId: null, verificada: false, sinal: null, comando: [] };
     const erroDeEstado = (0, phase_1.estadoParaDespacho)(raiz, thread, opcoes.dryRun);
     if (erroDeEstado)
         return { ...vazio, ok: false, motivo: 'tree.blocked', detalhe: erroDeEstado, dryRun: opcoes.dryRun === true };
-    if (!fs.existsSync(absoluto)) {
+    if (!achado) {
         return {
             ...vazio,
             ok: false,
             motivo: 'artifact.missing',
-            detalhe: `o prompt gravado sumiu do disco: ${promptRelativo}`,
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.promptSumiu(promptRelativo)),
             dryRun: opcoes.dryRun === true,
         };
     }
@@ -530,8 +613,7 @@ tomadaPrevia) {
             ...vazio,
             ok: false,
             motivo: 'artifact.missing',
-            detalhe: `o prompt em ${promptRelativo} mudou desde o despacho original ` +
-                `(sha256 ${shaAtual.slice(0, 12)} != ${sha.slice(0, 12)}): retomada e redespachar o MESMO texto`,
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.promptMudou(promptRelativo, shaAtual.slice(0, 12), sha.slice(0, 12))),
             dryRun: opcoes.dryRun === true,
         };
     }
@@ -579,8 +661,9 @@ tomadaPrevia) {
                 (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread.id), thread.id, ledger_1.TIPOS_DE_EVENTO.despachoIdempotente, { fase, promptSha256: sha, canal,
                     sessionId: tomada.atual.sessao, origem: opcoes.origem ?? 'retry',
                     razao: 'mesma fase e mesmo prompt de quem ja conduz: a sessao em andamento atende a retomada, sem sessao nova' });
+                const sessao = String(tomada.atual.sessao).slice(0, 8);
                 return { ...vazio, ok: true, sessionId: tomada.atual.sessao, motivo: null, dryRun: false,
-                    detalhe: `a sessao ${String(tomada.atual.sessao).slice(0, 8)} ja conduz a fase ${fase} com este prompt: nada foi redespachado` };
+                    detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.jaConduz(sessao, fase)) };
             }
             const recusa = (0, conducao_1.recusaDeConducao)(thread.id, tomada.atual, pedidoDeConducao);
             (0, conducao_1.registrarRecusa)(raiz, recusa);
@@ -589,7 +672,14 @@ tomadaPrevia) {
         conducao = tomada;
     }
     try {
-        const cwd = opcoes.cwd ?? thread.worktree ?? raiz;
+        // RM-047 (P2): o cwd do pedido da fila ou da worktree da thread so vale como worktree registrada no git.
+        let cwd;
+        try {
+            cwd = opcoes.cwd !== undefined ? (0, procedencia_1.exigirCwdLocal)(raiz, thread.id, opcoes.cwd, 'fila') : (0, procedencia_1.diretorioDaThread)(raiz, thread);
+        }
+        catch (e) {
+            return { ...vazio, ok: false, motivo: 'tree.blocked', detalhe: e.message, dryRun: opcoes.dryRun === true };
+        }
         // Mesma resolucao do `ork phase run`: a retomada carimba no ledger o trio que ela de
         // fato despachou, inclusive quando o pedido da fila trazia um modelo proprio. O setup
         // do bloco (feature #setup) vale aqui tambem: a fase retomada abre no MESMO runtime
@@ -601,11 +691,20 @@ tomadaPrevia) {
             effort: opcoes.effort ?? undefined,
         }, doBloco);
         const rt = (0, runtimes_1.resolverRuntime)(runtime);
+        // RM-047 (P1): a retomada recusa o sandbox afrouxado sem a confirmacao local, como o `ork phase run`.
+        const erroDePostura = (0, postura_local_1.recusaDePostura)(raiz, manifesto, runtime);
+        if (erroDePostura) {
+            if (!opcoes.dryRun)
+                (0, gates_1.registrarGateBloqueado)((0, thread_1.dirThread)(raiz, thread.id), thread.id, { gate: 'phase.dispatch',
+                    motivo: 'policy.violation', modo: thread.modo, detalhe: erroDePostura,
+                    correcao: (0, postura_local_1.comandoDeConfirmacao)((0, postura_local_1.posturaAfrouxada)(manifesto) ?? ''), fase, slug, origem: opcoes.origem ?? 'retry' });
+            return { ...vazio, ok: false, motivo: 'policy.violation', detalhe: erroDePostura, dryRun: opcoes.dryRun === true };
+        }
         if (!opcoes.dryRun && (0, phase_1.baselineDoDespachoNecessaria)(carregado, thread.id, { fase, prompt: '', runtime, model, effort })) {
             // Na primeira passada a tomada fica retida para a baseline (o `finally` nao a solta); na repeticao, o
             // `finally` devolve o que a tomada consumiu (A-1 do CHECK 3).
             const pendente = { ...vazio, ok: false, motivo: 'runtime.unavailable', dryRun: false,
-                detalhe: `baseline.pendente: o bloco com GO no ${runtime} precisa da baseline antes da retomada` };
+                detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.baselinePendente(runtime)) };
             if (!tomadaPrevia && conducao) {
                 pendente.retida = conducao;
                 conducao = null;
@@ -621,8 +720,9 @@ tomadaPrevia) {
                 contextoRuntime = (0, runtime_context_1.contextoDoProjeto)(raiz, runtime, cwd, thread.id);
             }
             catch (e) {
+                const erro = e.message;
                 return { ...vazio, ok: false, motivo: 'runtime.unavailable',
-                    detalhe: `runtime.unavailable: ${e.message}`, dryRun: opcoes.dryRun === true };
+                    detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.runtimeIndisponivel(erro)), dryRun: opcoes.dryRun === true };
             }
             if (contextoRuntime)
                 contextoRuntime.identidade = identidade;
@@ -668,7 +768,7 @@ tomadaPrevia) {
                 sessionId: null,
                 verificada: false,
                 motivo: null,
-                detalhe: 'ensaio (--dry-run): comando montado, nada despachado',
+                detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.ensaioDoRedespacho),
                 sinal: null,
                 comando: resultado.comando,
                 dryRun: true,
@@ -677,8 +777,19 @@ tomadaPrevia) {
         if (!resultado.ok || !resultado.sessionId) {
             (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread.id), thread.id, 'phase_dispatch_failed', { fase, runtime, slug, cwd,
                 promptPath: absoluto, promptSha256: sha, controlador: resultado.controlador, model, effort,
-                erro: resultado.erro ?? 'runtime.unavailable: sem sessionId', origem: 'retry', ...(perfil ? { perfil } : {}) });
+                erro: resultado.erro ?? 'runtime.unavailable: sem sessionId', stderr: (resultado.stderr ?? '').slice(0, 500),
+                origem: 'retry', ...(perfil ? { perfil } : {}) });
             const sinal = resultado.rateLimit ?? null;
+            // RM-055: o redespacho recusado pelo que so o dono resolve reabre a pausa dele, com o mesmo comando.
+            const impedimento = !resultado.falhaDeConta && !sinal
+                ? (0, impedimento_1.registrarImpedimentoDoDono)((0, thread_1.dirThread)(raiz, thread.id), thread, { fase, slug, runtime, cwd, origem: 'retry',
+                    promptPath: absoluto, promptSha256: sha, perfil, saida: `${resultado.stderr ?? ''}\n${resultado.erro ?? ''}` })
+                : null;
+            if (impedimento) {
+                return { ok: false, slug, sessionId: null, verificada: false, motivo: impedimento.motivo,
+                    detalhe: `${impedimento.motivo}: ${impedimento.trecho}`, sinal: null, falhaDeConta: null, perfil: perfil ?? null,
+                    comando: resultado.comando, controlador: resultado.controlador, dryRun: false };
+            }
             // I-33 (D5): a conta recusou o redespacho; o perfil sai do rodizio aqui, onde a evidencia esta.
             if (resultado.falhaDeConta) {
                 try {
@@ -693,7 +804,7 @@ tomadaPrevia) {
                 verificada: false,
                 // I-33 (D11b): falha de conta reconhecida na saida e o motivo mais especifico.
                 motivo: resultado.falhaDeConta?.motivo ?? (sinal ? 'runtime.rate-limited' : 'runtime.unavailable'),
-                detalhe: resultado.erro ?? 'sem sessionId na saida do runtime',
+                detalhe: resultado.erro ?? (0, locale_1.textoDoCatalogo)((m) => m.retry.semSessionId),
                 sinal,
                 falhaDeConta: resultado.falhaDeConta ?? null,
                 perfil: perfil ?? null,
@@ -728,8 +839,7 @@ tomadaPrevia) {
             sessionId: resultado.sessionId,
             verificada: resultado.verificada,
             motivo: null,
-            detalhe: `sessao ${resultado.sessionId} despachada com o mesmo prompt sha256 ${sha.slice(0, 12)}` +
-                (perfil ? ` no perfil ${perfil.id} (${runtime})` : ''),
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.redespachada(String(resultado.sessionId), sha.slice(0, 12), perfil ? perfil.id : null, runtime)),
             sinal: null,
             perfil: perfil ?? null,
             comando: resultado.comando,
@@ -1076,7 +1186,11 @@ function producaoNoIntervalo(raiz, thread, sessao, eventos) {
         // pelo shell nao passa pelo ledger, entao so o HEAD o revela.
         const registro = eventos.filter(e => e.tipo === 'session_sensor_registered' && e.sessionId === sessao.sessionId &&
             e.despachoEm === sessao.despachadaEm).at(-1);
-        const cwd = typeof registro?.cwd === 'string' ? registro.cwd : typeof despacho?.cwd === 'string' ? despacho.cwd : thread.worktree ?? raiz;
+        const doLedger = typeof registro?.cwd === 'string' ? registro.cwd : typeof despacho?.cwd === 'string' ? despacho.cwd : null;
+        // RM-047 (P2): git so roda em worktree registrada; cwd que nao vale e duvida, e duvida conta como producao.
+        const cwd = doLedger !== null ? (0, procedencia_1.cwdLocalOuNulo)(raiz, thread.id, doLedger, 'ledger') : (0, procedencia_1.cwdLocalOuNulo)(raiz, thread.id, thread.worktree ?? raiz, 'thread');
+        if (cwd === null)
+            return { produziu: true, evidencia: 'cwd do despacho fora das worktrees registradas; producao nao descartada' };
         const head = registro?.head;
         if (typeof head !== 'string' || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(head))
             return { produziu: true, evidencia: 'HEAD da worktree no despacho desconhecido; producao nao descartada' };
@@ -1121,6 +1235,17 @@ function jaMarcado(raiz, perfil, falha, agoraMs = Date.now()) {
         ? atual.estado === 'esgotado' && atual.esgotadoAte !== null && Date.parse(atual.esgotadoAte) > agoraMs
         : atual.estado === 'sem-auth';
 }
+/**
+ * RM-037 (fatia 5, aviso da rodada 1 do CHECK): a cota que o observador viu ao vivo (`runtime_quota_detected`, da mesma
+ * sessao e do mesmo despacho, com o mesmo prazo dito) ja tirou o perfil do rodizio ate a hora da mensagem. Marcar de
+ * novo aqui, depois dessa hora, pela janela padrao (A10), tiraria do rodizio uma conta que ja voltou.
+ */
+function cotaJaVistaAoVivo(eventos, gate, falha) {
+    if (falha.motivo !== 'runtime.quota-exhausted' || typeof gate?.sessionId !== 'string')
+        return false;
+    return eventos.some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.cotaVistaNaTranscricao && e.sessionId === gate.sessionId &&
+        e.despachoEm === gate.despachoEm && (e.resetEm ?? null) === falha.resetEm);
+}
 function sinalDoGate(gate, motivo) {
     const f = gate?.falhaDeConta;
     return { motivo: motivo === 'runtime.auth-missing' ? 'runtime.auth-missing' : 'runtime.quota-exhausted',
@@ -1209,7 +1334,7 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         return vazio;
     }
     const acaoBase = plano.politica?.acao ?? plano.acao;
-    const registrarTentativa = (ok, detalhe) => {
+    const registrarTentativa = (ok, detalhe, extra = {}) => {
         (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.retryTentado, {
             fase: plano.fase,
             motivo: plano.motivo,
@@ -1227,32 +1352,27 @@ function executarRetry(carregado, threadId, opcoes = {}) {
                 : `politica de retry do bloco B3 (bloco sem pausa no modo ${thread.modo})`,
             ok,
             detalhe,
+            ...extra,
         });
     };
     // I-36 (T6): conducao em andamento nao e fila de rate limit. Nada e redespachado; o registro diz
     // quem conduz, e a vez chega quando essa conducao terminar.
     if (plano.motivo === 'conducao.em-andamento') {
         const atual = (0, conducao_1.conducaoDaThread)(raiz, threadId);
-        const detalhe = atual
-            ? `${(0, conducao_texto_1.linhaDeConducao)(atual)}; nada foi redespachado, a vez chega quando essa conducao terminar`
-            : 'ninguem conduz a thread agora: o proximo pedido segue normalmente';
+        const detalhe = (0, locale_1.textoDoCatalogo)((m) => atual ? m.retry.conduzidaAgora((0, conducao_texto_1.linhaDeConducao)(atual)) : m.retry.ninguemConduz);
         registrarTentativa(!atual, detalhe);
         return { ...vazio, executada: false, detalhe };
     }
     // `esperar-janela`: quem retoma e a fila, e ela ja esta gravada em disco.
     if (acaoBase === 'esperar-janela') {
         const fila = (0, ratelimit_1.lerFilaDeRetomada)(raiz).filter((p) => p.thread === threadId && p.estado === 'aguardando');
-        const detalhe = fila.length > 0
-            ? `${fila.length} pedido(s) na fila duravel; o proximo libera em ${fila[0].liberaEm}`
-            : 'nenhum pedido aguardando na fila para esta thread';
+        const detalhe = (0, locale_1.textoDoCatalogo)((m) => fila.length > 0 ? m.retry.naFila(fila.length, fila[0].liberaEm) : m.retry.filaVazia);
         registrarTentativa(fila.length > 0, detalhe);
         return { ...vazio, executada: fila.length > 0, fila, detalhe };
     }
     if (acaoBase === 'sincronizar-worktree') {
         const sync = (0, worktree_1.sincronizarWorktree)(carregado, threadId, { dryRun: opcoes.dryRun });
-        const detalhe = sync.ok
-            ? `worktree sincronizada com a base (${sync.passos.join('; ')})`
-            : `sincronizacao nao concluiu: ${sync.detalhe}`;
+        const detalhe = (0, locale_1.textoDoCatalogo)((m) => sync.ok ? m.retry.sincronizada(sync.passos.join('; ')) : m.retry.sincronizacaoFalhou(sync.detalhe));
         registrarTentativa(sync.ok, detalhe);
         return { ...vazio, executada: sync.ok, sync, detalhe };
     }
@@ -1261,10 +1381,8 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         const reverify = opcoes.reverify && rodada.correcoes.length > 0
             ? (0, fix_1.reverificar)(carregado, threadId, { rodada: rodada.rodada })
             : null;
-        const detalhe = rodada.correcoes.length === 0
-            ? 'o CHECK passou no HEAD real: nao ha correcao a dirigir'
-            : `${rodada.correcoes.length} correcao(oes) na rodada ${rodada.rodada}` +
-                (reverify ? `; CHECK-REVERIFY: ${reverify.veredito}` : '');
+        const detalhe = (0, locale_1.textoDoCatalogo)((m) => rodada.correcoes.length === 0 ? m.retry.checkPassou
+            : m.retry.correcoesNaRodada(rodada.correcoes.length, rodada.rodada, reverify ? m.retry.vereditos[reverify.veredito] ?? reverify.veredito : null));
         registrarTentativa(rodada.correcoes.length > 0, detalhe);
         return { ...vazio, executada: rodada.correcoes.length > 0, rodada, reverify, detalhe };
     }
@@ -1274,14 +1392,41 @@ function executarRetry(carregado, threadId, opcoes = {}) {
     if (plano.motivo === 'runtime.model-unavailable') {
         return trocarDestinoDoModelo(carregado, thread, plano, opcoes, vazio, registrarTentativa);
     }
-    // `reexecutar` e `escalar-esforco`: o MESMO prompt volta ao runtime.
-    const falho = ultimoDespachoFalho(raiz, threadId, plano.fase, plano.motivo === 'runtime.silencio');
+    // `reexecutar` e `escalar-esforco`: o MESMO prompt volta ao runtime. RM-063 (F3): o gate que o plano leu diz de que
+    // despacho e o prompt; sem ele, a tentativa mais recente da fase com prompt gravado.
+    const reprovacao = ultimaReprovacao(raiz, threadId);
+    const gateDoPlano = reprovacao && reprovacao.motivo === plano.motivo && faseDoEvento(reprovacao, thread) === plano.fase
+        ? reprovacao : null;
+    const falho = despachoParaRedespachar((0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId)), plano.fase, gateDoPlano, plano.motivo === 'runtime.silencio');
     if (!falho || typeof falho.promptPath !== 'string' || typeof falho.promptSha256 !== 'string') {
-        const detalhe = `nao ha despacho falho registrado em ${plano.fase} com prompt gravado: ` +
-            `rode a fase de novo com \`ork phase run ${threadId} ${plano.fase} --prompt "..."\``;
+        const detalhe = (0, locale_1.textoDoCatalogo)((m) => m.retry.semDespachoFalho(plano.fase, threadId));
         registrarTentativa(false, detalhe);
         return { ...vazio, detalhe };
     }
+    // RM-055: o impedimento do dono com prova local (confianca do diretorio) so volta ao runtime depois de
+    // resolvido. Sem a prova, nada e despachado e a tentativa nao conta: a pausa do dono continua aberta.
+    if (plano.motivo && (0, impedimento_1.ehImpedimentoDoDono)(plano.motivo) && typeof falho.cwd === 'string') {
+        const perfilFalho = perfilDoEvento(falho);
+        const resolvido = (0, impedimento_1.impedimentoResolvido)(plano.motivo, { cwd: falho.cwd,
+            runtime: typeof falho.runtime === 'string' ? falho.runtime : '', configDir: perfilFalho?.configDir ?? null });
+        if (resolvido === false) {
+            const motivo = plano.motivo, cwd = falho.cwd;
+            const detalhe = (0, locale_1.textoDoCatalogo)((m) => m.retry.semConfianca(motivo, cwd, threadId));
+            return { ...vazio, detalhe };
+        }
+    }
+    // RM-063 (F3, GO-FIX): antes de devolver o prompt ao runtime, a prova de que nenhuma sessao viva trabalha na thread. O
+    // despacho que falhou depois de abrir a sessao (o `claude --bg` lento) e o adaptador que lanca deixariam duas sessoes
+    // na mesma worktree. Sem a prova, nada e redespachado, e a tentativa nao conta.
+    const ids = [falho.sessionId, gateDoPlano?.sessionId].filter((x) => typeof x === 'string' && !!x);
+    const viva = (0, vida_da_thread_1.sessaoVivaNaThread)(raiz, thread, ids);
+    if (!viva.respondeu || viva.sessionId) {
+        const { sessionId: sessao, detalhe: falhaDaConsulta } = viva;
+        const detalhe = sessao ? (0, locale_1.textoDoCatalogo)((m) => m.retry.sessaoAindaViva(sessao.slice(0, 8), threadId))
+            : (0, locale_1.textoDoCatalogo)((m) => m.retry.runtimeSemProva(falhaDaConsulta ?? '', threadId));
+        registrarTentativa(false, detalhe, { conta: false });
+        return { ...vazio, detalhe };
+    }
     const redespacho = redespachar(carregado, thread, plano.fase, falho.promptPath, falho.promptSha256, {
         effort: plano.effort,
         runtime: typeof falho.runtime === 'string' ? falho.runtime : null,
@@ -1289,7 +1434,11 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         origem: 'retry.run',
         dryRun: opcoes.dryRun,
     });
-    registrarTentativa(redespacho.ok, redespacho.detalhe);
+    // RM-055 (continuacao, D2): o runtime recusou o redespacho por um motivo que so o dono resolve. Nada rodou
+    // e a espera do dono voltou com o mesmo comando: a recusa fica no ledger, mas nao gasta tentativa nem sobe
+    // esforco. Contada, a quarta chamada escalava e o retry nunca mais re-despachava, nem depois do aceite.
+    const recusaDoDono = !redespacho.ok && (0, impedimento_1.ehImpedimentoDoDono)(redespacho.motivo);
+    registrarTentativa(redespacho.ok, redespacho.detalhe, recusaDoDono ? { conta: false } : {});
     return {
         ...vazio,
         executada: redespacho.ok,
@@ -1322,7 +1471,7 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
         return { ...vazio, detalhe: diagnostico };
     };
     if (!despacho || typeof despacho.promptPath !== 'string' || typeof despacho.promptSha256 !== 'string') {
-        const detalhe = `nao ha despacho com prompt gravado para ${motivo} em ${fase}: rode a fase de novo com ork phase run`;
+        const detalhe = (0, locale_1.textoDoCatalogo)((m) => m.retry.semDespachoComPrompt(motivo, fase));
         registrarTentativa(false, detalhe);
         return { ...vazio, detalhe };
     }
@@ -1334,14 +1483,14 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
             : perfilDoEvento(despacho);
     }
     catch (e) {
-        return escalar('perfil registrado invalido', `rotacao recusada: ${e.message}`);
+        const erro = e.message;
+        return escalar('perfil registrado invalido', (0, locale_1.textoDoCatalogo)((m) => m.retry.rotacaoRecusada(erro)));
     }
     // D11 (c): sessao que morreu por cota depois de produzir nao e redespachada.
     if (typeof gate?.sessionId === 'string' && typeof gate.despachoEm === 'string') {
         const producao = producaoNoIntervalo(raiz, thread, { sessionId: gate.sessionId, fase, despachadaEm: gate.despachoEm }, eventos);
         if (producao.produziu) {
-            return escalar('producao parcial sob falha da conta', `producao parcial sob ${motivo === 'runtime.quota-exhausted' ? 'cota esgotada' : 'auth ausente'}: ${producao.evidencia}; ` +
-                'a sessao nao e redespachada sobre a worktree alterada e a fase nao conclui sem o humano');
+            return escalar('producao parcial sob falha da conta', (0, locale_1.textoDoCatalogo)((m) => m.retry.producaoParcialConta(motivo === 'runtime.quota-exhausted', String(producao.evidencia))));
         }
     }
     const doBloco = (0, setup_1.configDoBloco)((0, setup_1.lerSetup)(raiz), thread.modo, fase);
@@ -1349,7 +1498,8 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
     const politica = (0, runtime_profiles_1.politicaDeRotacao)(manifesto);
     const falha = sinalDoGate(gate, motivo);
     // I-33 (D12): o observador ja marca o perfil no caminho terminal; remarcar empurraria o prazo a cada retry.
-    if (!opcoes.dryRun && perfil && !jaMarcado(raiz, perfil, falha)) {
+    // RM-037 (fatia 5, aviso da rodada 1 do CHECK): a cota que ele viu ao vivo ja marcou ate a hora da mensagem.
+    if (!opcoes.dryRun && perfil && !jaMarcado(raiz, perfil, falha) && !cotaJaVistaAoVivo(eventos, gate, falha)) {
         try {
             (0, ratelimit_1.marcarContaDaFalha)(carregado, perfil, falha);
         }
@@ -1398,8 +1548,8 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
         if (ultimo.falhaDeConta?.motivo !== 'runtime.model-unavailable')
             falhaAtual = ultimo.falhaDeConta ?? falhaAtual;
         if (tentativas >= plano.limite) {
-            return escalar('limite de tentativas na rotacao', `${tentativas} tentativa(s) de rotacao por ${motivo} em ${fase}, no limite de ` +
-                `${plano.limite} do manifesto: escalacao tipada pausa qualquer modo`);
+            const feitas = tentativas;
+            return escalar('limite de tentativas na rotacao', (0, locale_1.textoDoCatalogo)((m) => m.retry.limiteDaRotacao(feitas, motivo, fase, plano.limite)));
         }
     }
     // Sem destino: a fila so faz sentido quando algum perfil tem prazo para voltar. Sem perfil (ambiente do
@@ -1409,13 +1559,12 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
     const prazo = (0, runtime_profiles_1.prazoDaFila)((0, runtime_profiles_1.lerPerfisComContas)(raiz), runtimes, politica) ?? dito;
     if (!prazo && falhaAtual.motivo === 'runtime.auth-missing') {
         emitir(null, 'nenhum perfil com login em nenhum runtime da ordem de fallback');
-        return escalar('auth ausente sem alternativa', 'nenhum perfil com login conferido em nenhum runtime da ordem de fallback: ' +
-            'refaca o login com ork accounts add ou ork accounts check antes de retomar');
+        return escalar('auth ausente sem alternativa', (0, locale_1.textoDoCatalogo)((m) => m.retry.semLogin));
     }
     const liberaEm = prazo ?? new Date(Date.now() + (0, ratelimit_1.janelaPadraoMs)(manifesto)).toISOString();
     emitir(null, `nenhum perfil ativo em ${runtimes.join(', ')}: fila duravel ate ${liberaEm}`);
     if (opcoes.dryRun)
-        return { ...vazio, detalhe: `ensaio: entraria na fila duravel ate ${liberaEm}` };
+        return { ...vazio, detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.entrariaNaFila(liberaEm)) };
     const pedido = (0, ratelimit_1.enfileirar)(carregado, { thread: thread.id, fase, slug: typeof despacho.slug === 'string' ? despacho.slug : (0, phase_1.slugDaSessao)(thread, fase),
         promptPath: despacho.promptPath, promptSha256: despacho.promptSha256,
         cwd: typeof despacho.cwd === 'string' ? despacho.cwd : thread.worktree ?? raiz,
@@ -1426,7 +1575,7 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
         janelaEstimada: pedido.janelaEstimada, motivo: falhaAtual.motivo, promptSha256: despacho.promptSha256,
         correcao: `ork retry resume (ou aguarde ate ${pedido.liberaEm})` });
     registrarTentativa(true, `fila duravel: pedido ${pedido.id} libera em ${pedido.liberaEm}`);
-    return { ...vazio, executada: true, fila: [pedido], redespacho: ultimo, detalhe: `pedido ${pedido.id} na fila ate ${pedido.liberaEm}` };
+    return { ...vazio, executada: true, fila: [pedido], redespacho: ultimo, detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.pedidoAte(pedido.id, pedido.liberaEm)) };
 }
 /** RM-037 (defeitosdeco D-6): chave de um destino (runtime, perfil, modelo) que recusou o modelo. */
 function chaveDoModelo(runtime, perfil, model) {
@@ -1494,10 +1643,10 @@ function proximoDestinoDoModelo(raiz, runtime, model, fallback, recusados) {
     return null;
 }
 /** D-6: a correcao exata quando nenhum destino tem o modelo: o bloco do setup que conduz a fase. */
-function correcaoDoModelo(thread, fase) {
+function correcaoDoModelo(thread, fase, m = (0, locale_1.msg)()) {
     const indice = modos_1.MODOS[thread.modo]?.blocos.findIndex(b => b.fases.includes(fase)) ?? -1;
     const bloco = indice >= 0 ? String(indice + 1) : 'N';
-    return `ork setup ${thread.modo} --bloco ${bloco} --model <modelo acessivel>, ou declare no mesmo bloco --fallback runtime:modelo`;
+    return m.retry.correcaoDoModelo(thread.modo, bloco);
 }
 /**
  * RM-037 (defeitosdeco D-6): troca de destino depois de `runtime.model-unavailable`. O modelo pedido nao
@@ -1524,13 +1673,12 @@ function trocarDestinoDoModelo(carregado, thread, plano, opcoes, vazio, registra
         return { ...vazio, detalhe: diagnostico };
     };
     if (!despacho || typeof despacho.promptPath !== 'string' || typeof despacho.promptSha256 !== 'string') {
-        const detalhe = `nao ha despacho com prompt gravado para ${motivo} em ${fase}: rode a fase de novo com ork phase run`;
+        const detalhe = (0, locale_1.textoDoCatalogo)((m) => m.retry.semDespachoComPrompt(motivo, fase));
         registrarTentativa(false, detalhe);
         return { ...vazio, detalhe };
     }
     const runtime = typeof despacho.runtime === 'string' ? despacho.runtime : manifesto.runtime.adapter;
     const model = typeof despacho.model === 'string' ? despacho.model : null;
-    const rotulo = model ?? '(padrao do runtime)';
     let perfil;
     try {
         perfil = typeof gate?.sessionId === 'string'
@@ -1538,13 +1686,13 @@ function trocarDestinoDoModelo(carregado, thread, plano, opcoes, vazio, registra
             : perfilDoEvento(despacho);
     }
     catch (e) {
-        return escalar('perfil registrado invalido', `troca de destino recusada: ${e.message}`);
+        const erro = e.message;
+        return escalar('perfil registrado invalido', (0, locale_1.textoDoCatalogo)((m) => m.retry.trocaRecusada(erro)));
     }
     if (typeof gate?.sessionId === 'string' && typeof gate.despachoEm === 'string') {
         const producao = producaoNoIntervalo(raiz, thread, { sessionId: gate.sessionId, fase, despachadaEm: gate.despachoEm }, eventos);
         if (producao.produziu) {
-            return escalar('producao parcial com modelo inacessivel', `producao parcial com o modelo ${rotulo} inacessivel: ${producao.evidencia}; ` +
-                'a sessao nao e redespachada sobre a worktree alterada e a fase nao conclui sem o humano');
+            return escalar('producao parcial com modelo inacessivel', (0, locale_1.textoDoCatalogo)((m) => m.retry.producaoParcialModelo(model ?? m.retry.padraoDoRuntime, String(producao.evidencia))));
         }
     }
     const recusados = new Set([...destinosQueRecusaramOModelo(eventos, fase), chaveDoModelo(runtime, perfil?.id ?? null, model)]);
@@ -1570,8 +1718,7 @@ function trocarDestinoDoModelo(carregado, thread, plano, opcoes, vazio, registra
             origem: 'retry.modelo', dryRun: opcoes.dryRun,
         });
         if (opcoes.dryRun)
-            return { ...vazio, redespacho: r, detalhe: `ensaio: o mesmo prompt iria a ${alvo.runtime}` +
-                    `${alvo.perfil ? ` (perfil ${alvo.perfil.id})` : ''} com o modelo ${alvo.model ?? '(padrao do runtime)'}; ${r.detalhe}` };
+            return { ...vazio, redespacho: r, detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.ensaioDoModelo(alvo.runtime, alvo.perfil ? alvo.perfil.id : null, alvo.model ?? m.retry.padraoDoRuntime, (0, locale_1.remontar)(r.detalhe))) };
         registrarTentativa(r.ok, r.detalhe);
         tentativas += 1;
         if (r.ok)
@@ -1582,58 +1729,62 @@ function trocarDestinoDoModelo(carregado, thread, plano, opcoes, vazio, registra
         recusados.add(chaveDoModelo(alvo.runtime, alvo.perfil?.id ?? null, alvo.model));
         atual = { runtime: alvo.runtime, perfil: alvo.perfil, model: alvo.model };
         if (tentativas >= plano.limite) {
-            return escalar('limite de tentativas na troca de modelo', `${tentativas} tentativa(s) de troca por ${motivo} em ${fase}, no limite de ` +
-                `${plano.limite} do manifesto: escalacao tipada pausa qualquer modo`);
+            const feitas = tentativas;
+            return escalar('limite de tentativas na troca de modelo', (0, locale_1.textoDoCatalogo)((m) => m.retry.limiteDaTroca(feitas, motivo, fase, plano.limite)));
         }
     }
     const tentados = [...recusados].map(k => { const [rt, p, m] = k.split('|'); return `${rt}${p ? `/${p}` : ''}:${m || '(padrao)'}`; });
-    return escalar('modelo inacessivel sem outro destino', `o modelo ${rotulo} nao esta acessivel em ${tentados.join(', ')} e o bloco ` +
-        `nao tem outro destino: ${correcaoDoModelo(thread, fase)}`);
+    return escalar('modelo inacessivel sem outro destino', (0, locale_1.textoDoCatalogo)((m) => m.retry.modeloSemDestino(model ?? m.retry.padraoDoRuntime, tentados.join(', '), correcaoDoModelo(thread, fase, m))));
 }
 /** Texto de `ork retry plan`. */
 function textoDoPlano(p) {
+    // RM-061 (F2b, G2): a razao e o detalhe que este processo montou saem remontados no locale; o detalhe lido
+    // do ledger (gravado por outro processo) e a politica pelo motivo saem como o catalogo os traz.
+    const m = (0, locale_1.msg)().retry;
     const linhas = [];
-    linhas.push(`Plano de retry da thread ${p.thread}`);
-    linhas.push(`  modo            ${p.modo}`);
-    linhas.push(`  fase            ${p.fase ?? '(nenhuma)'}`);
-    linhas.push(`  motivo tipado   ${p.motivo ?? '(nenhuma reprovacao pendente)'}`);
+    linhas.push(m.titulo(p.thread));
+    linhas.push(m.modo(p.modo));
+    linhas.push(m.fase(p.fase));
+    linhas.push(m.motivo(p.motivo));
+    const detalhe = (0, locale_1.remontar)(p.detalhe);
     if (p.detalhe)
-        linhas.push(`  detalhe         ${(0, horario_1.localizarTexto)(p.detalhe)}`);
-    linhas.push(`  acao            ${p.acao}`);
-    linhas.push(`  tentativas      ${p.tentativas} de ${p.limite} antes da escalacao`);
-    linhas.push(`  esforco         ${p.effort}${p.effort !== p.effortAnterior ? ` (escalado de ${p.effortAnterior})` : ''}`);
-    linhas.push(`  automatica      ${p.automatica ? 'sim' : 'nao'}`);
+        linhas.push(m.detalhe((0, horario_1.localizarTexto)(detalhe)));
+    linhas.push(m.acao(p.acao));
+    linhas.push(m.tentativas(p.tentativas, p.limite));
+    linhas.push(m.esforco(p.effort, p.effort !== p.effortAnterior ? p.effortAnterior : null));
+    linhas.push(m.automatica(p.automatica));
     if (p.bloqueio)
-        linhas.push(`  bloqueio        ${p.bloqueio}`);
-    linhas.push(`  razao           ${p.razao}`);
+        linhas.push(m.bloqueio(p.bloqueio));
+    linhas.push(m.razao((0, locale_1.remontar)(p.razao)));
     if (p.politica && !p.automatica)
-        linhas.push(`  correcao        ${p.politica.correcao}`);
-    if (p.detalhe && (0, horario_1.localizarTexto)(p.detalhe) !== p.detalhe)
+        linhas.push(m.correcao(p.motivo ? m.politica[p.motivo].correcao : p.politica.correcao));
+    if (p.detalhe && (0, horario_1.localizarTexto)(detalhe) !== detalhe)
         linhas.push((0, horario_1.legendaDoFuso)());
     return linhas.join('\n');
 }
 /** Texto de `ork retry run`. */
 function textoDoRetry(r) {
+    const m = (0, locale_1.msg)().retry;
     const plano = textoDoPlano(r.plano);
     const linhas = [plano, ''];
-    linhas.push(`Execucao: ${r.executada ? 'acao executada' : 'nada executado'}`);
-    linhas.push(`  ${(0, horario_1.localizarTexto)(r.detalhe)}`);
+    const detalhe = (0, locale_1.remontar)(r.detalhe);
+    linhas.push(m.execucao(r.executada));
+    linhas.push(m.linhaDoDetalhe((0, horario_1.localizarTexto)(detalhe)));
     if (r.rodada && r.rodada.correcoes.length > 0) {
         linhas.push('');
-        linhas.push(`GO-FIX rodada ${r.rodada.rodada}: ` +
-            r.rodada.correcoes.map((c) => `${c.id} (tipo ${c.tipo}, ${c.origem})`).join(', '));
+        linhas.push(m.rodada(r.rodada.rodada, r.rodada.correcoes.map((c) => m.correcaoDaRodada(c.id, c.tipo, c.origem)).join(', ')));
     }
     if (r.reverify) {
-        linhas.push(`CHECK-REVERIFY: ${r.reverify.veredito} (cobertura ${r.reverify.cobertura})`);
+        linhas.push(m.reverify(m.vereditos[r.reverify.veredito] ?? r.reverify.veredito, m.coberturas[r.reverify.cobertura] ?? r.reverify.cobertura));
     }
     if (r.fila.length > 0) {
         linhas.push('');
-        linhas.push('Fila de rate limit desta thread:');
+        linhas.push(m.fila);
         for (const p of r.fila) {
-            linhas.push(`  ${p.id}  ${p.fase}  libera em ${(0, horario_1.formatarDataHora)(p.liberaEm)}${p.janelaEstimada ? ' (janela estimada)' : ''}`);
+            linhas.push(m.pedidoNaFila(p.id, p.fase, (0, horario_1.formatarDataHora)(p.liberaEm), p.janelaEstimada));
         }
     }
-    if ((r.fila.length > 0 || (0, horario_1.localizarTexto)(r.detalhe) !== r.detalhe) && !plano.includes((0, horario_1.legendaDoFuso)())) {
+    if ((r.fila.length > 0 || (0, horario_1.localizarTexto)(detalhe) !== detalhe) && !plano.includes((0, horario_1.legendaDoFuso)())) {
         linhas.push((0, horario_1.legendaDoFuso)());
     }
     return linhas.join('\n');