@orkastery/cli 0.5.3 → 0.6.0

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.LIMITE_SEM_PROVA = 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;
@@ -53,6 +55,7 @@ exports.cancelarPedido = cancelarPedido;
 exports.alvosDeFallback = alvosDeFallback;
 exports.proximoAlvo = proximoAlvo;
 exports.producaoNoIntervalo = producaoNoIntervalo;
+exports.recusasSemProvaSeguidas = recusasSemProvaSeguidas;
 exports.executarRetry = executarRetry;
 exports.textoDoPlano = textoDoPlano;
 exports.textoDoRetry = textoDoRetry;
@@ -86,6 +89,10 @@ 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 runtime_escada_1 = require("./runtime-escada");
+const claude_bg_2 = require("./adapters/claude-bg");
 const phase_1 = require("./phase");
 const runtime_context_1 = require("./runtime-context");
 const slug_1 = require("./slug");
@@ -104,6 +111,13 @@ 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");
+const retomada_checkpoint_1 = require("./retomada-checkpoint");
+/** 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.
  *
@@ -129,29 +143,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',
@@ -161,95 +171,81 @@ 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,
-        porque: 'o perfil foi pedido pelo dono (--perfil) e nao existe no store ou e de outro runtime: repetir o pedido daria a mesma recusa, e trocar de perfil sozinho desobedeceria o pedido',
-        correcao: 'ork accounts list mostra os perfis de cada runtime; repita o despacho com um perfil do runtime certo ou sem --perfil',
+        ...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
-    // rotacao so redespacha quando a prova do `ork` confirma que o intervalo nao produziu nada;
-    // producao parcial sob cota esgotada vira `human.pending`, nunca redespacho sobre a worktree.
+    // I-33 (D5, D11) + RM-064 T3: a falha e da CONTA. O perfil sai do rodizio e o pedido segue ao
+    // proximo perfil ativo, depois ao fallback e por ultimo a fila. Interrupcao no meio da fase leva
+    // checkpoint derivado do ledger/Git; o prompt original permanece gravado e referenciado.
     'runtime.quota-exhausted': {
         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.
@@ -257,8 +253,7 @@ 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.
@@ -266,36 +261,31 @@ exports.POLITICA_DE_RETRY = {
         motivo: 'runtime.workspace-untrusted',
         acao: 'reexecutar',
         automatica: true,
-        porque: 'o runtime recusou o diretorio da worktree antes de rodar qualquer coisa: depois que o dono aceita a confianca no terminal, o MESMO prompt, com o mesmo sha256, volta a mesma fase; enquanto a confianca nao aparece no .claude.json da conta, nada e despachado',
-        correcao: 'o dono roda o comando da pausa (cd <worktree> && claude, aceita a confianca); ork retry run <thread> re-despacha o prompt ja gravado',
+        ...TEXTOS_DA_POLITICA['runtime.workspace-untrusted'],
     },
     'runtime.consent-pending': {
         motivo: 'runtime.consent-pending',
         acao: 'reexecutar',
         automatica: true,
-        porque: 'o runtime espera o dono aceitar termos novos antes de rodar qualquer coisa: depois do aceite, o MESMO prompt, com o mesmo sha256, volta a mesma fase; se o runtime recusar de novo, a mesma pausa do dono volta',
-        correcao: 'o dono abre o CLI do runtime e aceita os termos; ork retry run <thread> re-despacha o prompt ja gravado',
+        ...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,
-        porque: 'sem inode seguro, a remocao forcada exige avaliar a posse antes de retomar',
-        correcao: 'ork lease release <nome> --forcar; depois repita a aquisicao',
+        ...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.
@@ -303,8 +293,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.
@@ -312,15 +301,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. */
@@ -333,13 +320,15 @@ function podeReexecutar(motivo) {
 }
 /** Tabela de `ork retry policy`. */
 function tabelaDaPolitica() {
+    const m = (0, locale_1.msg)().retry;
+    const c = m.complementar;
     const linhas = Object.values(exports.POLITICA_DE_RETRY).map((p) => [
         p.motivo,
         p.acao,
-        p.automatica ? 'sim' : 'nao',
-        p.porque,
+        p.automatica ? c.sim : c.nao,
+        m.politica[p.motivo].porque,
     ]);
-    return (0, util_1.tabela)(['MOTIVO TIPADO', 'ACAO DE RETRY', 'AUTOMATICA', 'POR QUE'], linhas);
+    return (0, util_1.tabela)([...c.colunasPolitica], linhas);
 }
 /** A fase a que um evento de gate reprovado se refere. */
 function faseDoEvento(evento, thread) {
@@ -369,7 +358,12 @@ 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;
+    const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId));
+    // RM-063 (F4): a escada de `runtime.unavailable` vale por episodio, e as tentativas dela tambem: o pedido novo da fase
+    // (`ork phase run`) recomeca a contagem.
+    const desde = motivo === 'runtime.unavailable' ? (0, runtime_escada_1.inicioDoEpisodio)(eventos, fase) : -1;
+    // RM-055 (continuacao, D2): a recusa pelo impedimento do dono fica no ledger com `conta: false` e nao conta.
+    return eventos.filter((e, i) => i > desde && 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) {
@@ -397,7 +391,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,
@@ -406,7 +400,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);
@@ -429,7 +423,18 @@ 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),
+        };
+    }
+    // RM-063 (F4): a escada de `runtime.unavailable` diz o proximo degrau do episodio; sem degrau, o dono e chamado.
+    const escada = motivo === 'runtime.unavailable' ? (0, runtime_escada_1.estadoDaEscada)((0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId)), fase) : null;
+    const naEscada = escada ? { degrau: escada.proximo, tipo: escada.proximo ? runtime_escada_1.DEGRAUS_DA_ESCADA[escada.proximo - 1] : null,
+        consumidos: escada.consumidos.map((d) => ({ degrau: d.degrau, tipo: d.tipo, resultado: d.resultado, em: d.em })) } : null;
+    if (escada && escada.proximo === null) {
+        return {
+            thread: threadId, modo: thread.modo, fase, motivo, detalhe, politica, acao: 'escalar-humano', tentativas, limite,
+            effort: effortBase, effortAnterior: effortBase, automatica: false, bloqueio: 'escalacao.limite',
+            razao: (0, locale_1.textoDoCatalogo)((m) => m.retry.escada.esgotada((0, runtime_escada_1.resumoDosDegraus)(escada.consumidos))), escada: naEscada,
         };
     }
     // Limite de escalacao: pausa QUALQUER modo, inclusive #Auto.
@@ -448,14 +453,14 @@ 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.
     // `tentativas` e quantas JA rodaram, entao a 1a tentativa (tentativas 0) sai no
     // esforco base do manifesto e so a partir da 2a a escada anda.
-    const escala = manifesto.retry.escalar_esforco && tentativas >= 1;
+    // RM-063 (F4): runtime fora nao e prompt fraco. A escada de `runtime.unavailable` troca o destino, nunca o esforco.
+    const escala = manifesto.retry.escalar_esforco && tentativas >= 1 && !escada;
     const effortAnterior = escalarEsforco(effortBase, Math.max(0, tentativas - 1));
     const effort = escala ? escalarEsforco(effortBase, tentativas) : effortBase;
     const acao = escala ? 'escalar-esforco' : politica.acao;
@@ -465,9 +470,14 @@ 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);
+    // RM-063 (F4): o plano de `runtime.unavailable` diz o degrau da escada que a execucao sobe.
+    const degrau = escada?.proximo ?? null;
+    if (degrau)
+        razao = (0, locale_1.textoDoCatalogo)((m) => m.retry.escada.proximo(degrau, m.retry.escada.degraus[runtime_escada_1.DEGRAUS_DA_ESCADA[degrau - 1]]));
+    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';
@@ -477,10 +487,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);
@@ -488,12 +496,12 @@ 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 {
         thread: threadId, modo: thread.modo, fase, motivo, detalhe, politica, acao, tentativas,
-        limite, effort, effortAnterior, automatica, bloqueio, razao,
+        limite, effort, effortAnterior, automatica, bloqueio, razao, ...(naEscada ? { escada: naEscada } : {}),
     };
 }
 /** O esforco depois de `n` escaladas a partir do esforco base do manifesto. */
@@ -534,39 +542,110 @@ 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,
         };
     }
-    const prompt = fs.readFileSync(absoluto, 'utf8');
-    const shaAtual = (0, phase_1.hashDoPrompt)(prompt);
+    const promptOriginal = fs.readFileSync(absoluto, 'utf8');
+    const shaAtual = (0, phase_1.hashDoPrompt)(promptOriginal);
     if (shaAtual !== sha) {
         return {
             ...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,
         };
     }
+    const retomada = opcoes.checkpoint ? (0, retomada_checkpoint_1.prepararPromptDeRetomada)(raiz, thread, fase, { prompt: promptOriginal, promptPath: absoluto, promptSha256: sha }, !opcoes.dryRun) : null;
+    const prompt = retomada?.prompt ?? promptOriginal;
+    const promptExecutadoPath = retomada?.promptPath ?? absoluto;
+    const promptExecutadoSha = retomada?.promptSha256 ?? sha;
     const violacoes = (0, policies_1.bloqueantes)((0, policies_1.avaliarPolicies)(manifesto, { gate: 'phase.dispatch', prompt }));
     if (violacoes.length > 0) {
         const motivo = (0, policies_1.motivoDominante)(violacoes);
@@ -580,7 +659,7 @@ tomadaPrevia) {
             fase,
             slug,
             origem: opcoes.origem ?? 'retry',
-            evidencia: `prompt sha256 ${sha} (retomada recusada antes de despachar)`,
+            evidencia: `prompt sha256 ${promptExecutadoSha} (origem ${sha}; retomada recusada antes de despachar)`,
         });
         return { ...vazio, ok: false, motivo, detalhe, dryRun: opcoes.dryRun === true };
     }
@@ -591,7 +670,7 @@ tomadaPrevia) {
         : (0, runtime_context_1.novaIdentidadeDeDespacho)(thread.id, fase);
     const canal = opcoes.canal ?? (0, conducao_1.canalDoProcesso)();
     const doBlocoDaConducao = (0, setup_1.limitesDoBloco)(manifesto, (0, setup_1.lerSetup)(raiz), thread.modo, fase);
-    const pedidoDeConducao = { canal, correlacao: null, operacao: 'retry.run', fase, promptSha256: sha,
+    const pedidoDeConducao = { canal, correlacao: null, operacao: 'retry.run', fase, promptSha256: promptExecutadoSha,
         identidade: identidade.dispatchId, prazoMs: (0, phase_1.prazoDaSessao)(doBlocoDaConducao) };
     let conducao = null;
     if (tomadaPrevia) {
@@ -608,11 +687,12 @@ tomadaPrevia) {
         const tomada = (0, conducao_1.tomarConducao)(raiz, thread.id, pedidoDeConducao);
         if (!tomada.ok) {
             if (tomada.idempotente && tomada.atual) {
-                (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread.id), thread.id, ledger_1.TIPOS_DE_EVENTO.despachoIdempotente, { fase, promptSha256: sha, canal,
+                (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread.id), thread.id, ledger_1.TIPOS_DE_EVENTO.despachoIdempotente, { fase, promptSha256: promptExecutadoSha, 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);
@@ -621,7 +701,15 @@ 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);
+        }
+        // RM-061 (F3b, GO-FIX 1): o erro do catalogo fica registrado, e a impressao o remonta.
+        catch (e) {
+            return { ...vazio, ok: false, motivo: 'tree.blocked', detalhe: (0, locale_1.textoDoErro)(e), 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
@@ -633,32 +721,39 @@ 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;
             }
             return pendente;
         }
-        // D14 (GO-FIX 2): a retomada claude-bg abre com a mesma colaboração e o mesmo contexto de
-        // runtime do `ork phase run`; sem eles, o PLAN retomado saía sem negar Edit, Write e
-        // NotebookEdit e sem a allowlist do núcleo. O ramo Codex não muda.
+        // RM-064 T8: toda retomada abre com o mesmo contexto de runtime do `ork phase run`.
+        // Sem ele, a escada que troca para Codex perde o MCP vinculado à thread e ao despacho.
         let contextoRuntime;
-        if (runtime === 'claude-bg') {
-            try {
-                contextoRuntime = (0, runtime_context_1.contextoDoProjeto)(raiz, runtime, cwd, thread.id);
-            }
-            catch (e) {
-                return { ...vazio, ok: false, motivo: 'runtime.unavailable',
-                    detalhe: `runtime.unavailable: ${e.message}`, dryRun: opcoes.dryRun === true };
-            }
-            if (contextoRuntime)
-                contextoRuntime.identidade = identidade;
+        try {
+            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: (0, locale_1.textoDoCatalogo)((m) => m.retry.runtimeIndisponivel(erro)), dryRun: opcoes.dryRun === true };
+        }
+        if (contextoRuntime)
+            contextoRuntime.identidade = identidade;
         // I-33 (D4, D7): a retomada escolhe o perfil como o `ork phase run`, com o login conferido.
         let escolha;
         try {
@@ -686,10 +781,11 @@ tomadaPrevia) {
             dryRun: opcoes.dryRun,
             sandbox: manifesto.runtime.sandbox,
             logDir: path.join((0, thread_1.dirThread)(raiz, thread.id), 'sessoes'),
-            vinculo: { thread: thread.id, fase, promptSha256: sha },
+            vinculo: { thread: thread.id, fase, promptSha256: promptExecutadoSha },
             ...(perfil ? { perfil } : {}),
             // RM-037 (defeito 2): o modo plano segue a mesma regra do `ork phase run`, pelo bloco.
-            ...(runtime === 'claude-bg' ? { contextoRuntime, ...((0, phase_1.modoDaSessaoDoBloco)(thread, fase).plano ? { colaboracao: 'plan' } : {}) } : {}),
+            contextoRuntime,
+            ...(runtime === 'claude-bg' && (0, phase_1.modoDaSessaoDoBloco)(thread, fase).plano ? { colaboracao: 'plan' } : {}),
             // I-36 (D4): a sessao retomada herda a identidade do despacho e o canal, como no `ork phase run`.
             ambienteExtra: (0, conducao_1.ambienteDaConducao)(identidade.dispatchId, thread.id, canal),
         });
@@ -700,22 +796,28 @@ 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,
             };
         }
         if (!resultado.ok || !resultado.sessionId) {
+            // RM-063 (F4, GO-FIX): o `claude --bg` lento diz o id e estoura o prazo com a sessao aberta. A falha guarda a sessao,
+            // como no `ork phase run`: e por ela que o retry e a escada provam que ninguem trabalha na worktree antes de outro
+            // destino.
+            const daSessao = resultado.sessionId ? { sessionId: 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,
+                promptPath: promptExecutadoPath, promptSha256: promptExecutadoSha,
+                ...(retomada ? { promptOriginalPath: absoluto, promptOriginalSha256: sha } : {}),
+                controlador: resultado.controlador, model, effort,
                 erro: resultado.erro ?? 'runtime.unavailable: sem sessionId', stderr: (resultado.stderr ?? '').slice(0, 500),
-                origem: 'retry', ...(perfil ? { perfil } : {}) });
+                origem: 'retry', ...(perfil ? { perfil } : {}), ...daSessao });
             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 ?? ''}` })
+                    promptPath: promptExecutadoPath, promptSha256: promptExecutadoSha, perfil, saida: `${resultado.stderr ?? ''}\n${resultado.erro ?? ''}` })
                 : null;
             if (impedimento) {
                 return { ok: false, slug, sessionId: null, verificada: false, motivo: impedimento.motivo,
@@ -732,11 +834,11 @@ tomadaPrevia) {
             return {
                 ok: false,
                 slug,
-                sessionId: null,
+                sessionId: resultado.sessionId ?? null,
                 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,
@@ -754,8 +856,9 @@ tomadaPrevia) {
             thread,
             fase,
             slug,
-            promptPath: absoluto,
-            promptSha256: sha,
+            promptPath: promptExecutadoPath,
+            promptSha256: promptExecutadoSha,
+            ...(retomada ? { promptOriginal: { path: absoluto, sha256: sha } } : {}),
             runtime,
             cwd,
             model,
@@ -771,11 +874,11 @@ 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), promptExecutadoSha.slice(0, 12), perfil ? perfil.id : null, runtime)),
             sinal: null,
             perfil: perfil ?? null,
             comando: resultado.comando,
+            controlador: resultado.controlador,
             dryRun: false,
         };
     }
@@ -828,6 +931,15 @@ function playbookDaRetomada(carregado, pedido, opcoes = {}) {
 function retomarPedido(carregado, pedidoOriginal, opcoes = {}) {
     const { raiz } = carregado;
     const quando = opcoes.quando ?? (0, util_1.agora)();
+    // RM-058 N4 (D17 da ork-rm058n4): o pedido do despacho de um arco #Noctum é retomado pelo vigia do arco, pelo passo dele
+    // (conferência do envelope e reserva). Aqui ele não é redespachado nem regravado, e o ledger da thread não muda.
+    const arco = (0, ratelimit_1.arcoDoPedido)(pedidoOriginal);
+    if (arco) {
+        return { pedido: pedidoOriginal, playbook: 'mesma-sessao', slug: pedidoOriginal.slug, despachada: false, sessionId: null, verificada: false,
+            motivo: null, dryRun: opcoes.dryRun === true,
+            detalhe: `o pedido ${pedidoOriginal.id} é do arco ${arco}: quem o retoma é o vigia do arco, com a conferência do envelope e a reserva; ` +
+                `nada foi despachado (sem o vigia, o dono tira o pedido da fila com ork retry cancel ${pedidoOriginal.id} --motivo "..." e retoma a fase à mão)` };
+    }
     const thread = (0, thread_1.lerThread)(raiz, pedidoOriginal.thread);
     const dir = (0, thread_1.dirThread)(raiz, thread.id);
     let pedido = pedidoOriginal;
@@ -906,6 +1018,7 @@ function retomarPedido(carregado, pedidoOriginal, opcoes = {}) {
             effort: alvo.effort,
             cwd: pedido.cwd,
             origem: 'retry.rate-limit',
+            checkpoint: doPedido.checkpoint === true,
             dryRun: opcoes.dryRun,
         });
     (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.retryTentado, {
@@ -1017,7 +1130,8 @@ function alvoDaRetomada(carregado, thread, pedido) {
     const principal = pedido.runtime ?? doBloco?.runtime ?? manifesto.runtime.adapter;
     const candidatos = [{ runtime: principal, model: pedido.model, effort: pedido.effort },
         ...alvosDeFallback(doBloco, doBloco?.runtime ?? manifesto.runtime.adapter).filter(f => f.runtime !== principal)
-            .map(f => ({ runtime: f.runtime, model: f.model, effort: f.effort ?? pedido.effort }))];
+            .map(f => ({ runtime: f.runtime, model: f.model, effort: f.effort ?? pedido.effort }))]
+        .filter(c => (0, runtime_context_1.capacidadeDoRuntimeNoProjeto)(raiz, c.runtime).capaz);
     const runtimes = candidatos.map(c => c.runtime);
     const store = (0, runtime_profiles_1.lerPerfisComContas)(raiz), politica = (0, runtime_profiles_1.politicaDeRotacao)(manifesto);
     for (const c of candidatos) {
@@ -1078,11 +1192,12 @@ function alvosDeFallback(bloco, principal) {
 function proximoAlvo(raiz, atual, fallback, excluir, politica, agoraMs = Date.now()) {
     const store = (0, runtime_profiles_1.lerPerfisComContas)(raiz, agoraMs);
     const perfis = [...excluir.perfis, ...(atual.perfil ? [atual.perfil.id] : [])];
-    const mesmo = (0, runtime_profiles_1.proximoPerfilDisponivel)(store, atual.runtime, politica, { excluir: perfis, agoraMs });
+    const mesmo = (0, runtime_context_1.capacidadeDoRuntimeNoProjeto)(raiz, atual.runtime).capaz
+        ? (0, runtime_profiles_1.proximoPerfilDisponivel)(store, atual.runtime, politica, { excluir: perfis, agoraMs }) : null;
     if (mesmo)
         return { runtime: atual.runtime, perfil: (0, runtime_profiles_1.perfilDeDespacho)(mesmo), model: null, effort: null };
     for (const f of fallback) {
-        if (f.runtime === atual.runtime)
+        if (f.runtime === atual.runtime || !(0, runtime_context_1.capacidadeDoRuntimeNoProjeto)(raiz, f.runtime).capaz)
             continue;
         if ((0, runtime_profiles_1.perfisDoRuntime)(store, f.runtime).length > 0) {
             const p = (0, runtime_profiles_1.proximoPerfilDisponivel)(store, f.runtime, politica, { excluir: perfis, agoraMs });
@@ -1119,7 +1234,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' };
@@ -1192,6 +1311,25 @@ function ultimoDespachoFalho(raiz, threadId, fase, silencio = false) {
     }
     return null;
 }
+/**
+ * RM-063 (F4, GO-FIX): quantas recusas seguidas, no episodio da fase, sairam porque o runtime nao respondeu a prova de
+ * vida (`semProva`). Uma tentativa que andou (contada, ou recusada com sessao viva) zera a conta.
+ */
+function recusasSemProvaSeguidas(eventos, fase) {
+    const desde = (0, runtime_escada_1.inicioDoEpisodio)(eventos, fase);
+    let seguidas = 0;
+    for (let i = eventos.length - 1; i > desde; i--) {
+        const e = eventos[i];
+        if (e.tipo !== ledger_1.TIPOS_DE_EVENTO.retryTentado || e.fase !== fase || e.motivo !== 'runtime.unavailable')
+            continue;
+        if (e.semProva !== true)
+            break;
+        seguidas += 1;
+    }
+    return seguidas;
+}
+/** Recusas seguidas sem resposta do runtime, no mesmo episodio, ate o dono ser chamado. */
+exports.LIMITE_SEM_PROVA = 3;
 /**
  * Executa a acao de retry do ultimo gate reprovado da thread.
  *
@@ -1237,6 +1375,28 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         razao: plano.razao,
     });
     if (!plano.automatica || plano.motivo === null) {
+        // RM-063 (F4, GO-FIX, achado 9): a escada esgotada pelo plano (a sessao do ultimo degrau morreu depois) chama o dono
+        // pela escada, com as alternativas e o comando que retoma com o mesmo prompt; a escalada generica so repetia o retry.
+        if (plano.motivo === 'runtime.unavailable' && plano.escada && plano.escada.degrau === null && plano.fase && !opcoes.dryRun) {
+            const eventos = (0, ledger_1.lerLedger)(dir);
+            const ultimo = despachoParaRedespachar(eventos, plano.fase, null);
+            if (ultimo && typeof ultimo.promptPath === 'string' && typeof ultimo.promptSha256 === 'string') {
+                const origem = (0, runtime_escada_1.destinoDoEpisodio)(eventos, plano.fase);
+                let perfil = null;
+                try {
+                    perfil = perfilDoEvento(ultimo);
+                }
+                catch {
+                    perfil = null;
+                }
+                const despacho = { promptPath: localizarPromptGravado(raiz, threadId, ultimo.promptPath, ultimo.promptSha256) ?? ultimo.promptPath,
+                    promptSha256: ultimo.promptSha256, perfil: origem?.perfil ?? perfil,
+                    runtime: origem?.runtime ?? (typeof ultimo.runtime === 'string' ? ultimo.runtime : carregado.manifesto.runtime.adapter),
+                    model: origem?.model ?? null, effort: origem?.effort ?? null };
+                const detalhe = (0, runtime_escada_1.escalarEscada)(carregado, thread, plano.fase, despacho, (0, runtime_escada_1.estadoDaEscada)(eventos, plano.fase).consumidos, plano.tentativas, plano.limite);
+                return { ...vazio, detalhe };
+            }
+        }
         // Escalacao e custo viram gate humano explicito no ledger, nao silencio.
         if (plano.bloqueio === 'escalacao.limite' || plano.acao === 'sem-retry') {
             (0, gates_1.registrarGateBloqueado)(dir, threadId, {
@@ -1263,7 +1423,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,
@@ -1281,32 +1441,28 @@ 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}`;
+        // RM-061 (F3b): o detalhe da worktree tambem vem do catalogo; remontado aqui, ele segue o locale da impressao.
+        const detalhe = (0, locale_1.textoDoCatalogo)((m) => sync.ok ? m.retry.sincronizada(sync.passos.join('; ')) : m.retry.sincronizacaoFalhou((0, locale_1.remontar)(sync.detalhe)));
         registrarTentativa(sync.ok, detalhe);
         return { ...vazio, executada: sync.ok, sync, detalhe };
     }
@@ -1315,10 +1471,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 };
     }
@@ -1328,11 +1482,14 @@ 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 };
     }
@@ -1343,11 +1500,76 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         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 detalhe = `${plano.motivo}: o runtime ainda nao confia em ${falho.cwd}; nada foi despachado. ` +
-                `Rode \`cd ${falho.cwd} && claude\`, aceite a confianca e repita \`ork retry run ${threadId}\``;
+            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 provar = (conhecidos) => (0, vida_da_thread_1.sessaoVivaNaThread)(raiz, thread, conhecidos);
+    let viva = provar(ids);
+    // RM-063 (F4): `runtime.unavailable` sobe a escada de recuperacao (reerguer o daemon, o fallback do bloco, outro perfil),
+    // sempre com o mesmo prompt e o mesmo sha256. Ate aqui o retry so sabia repetir o destino que tinha acabado de falhar.
+    if (plano.motivo === 'runtime.unavailable') {
+        let perfilFalho = null;
+        try {
+            perfilFalho = perfilDoEvento(falho);
+        }
+        catch {
+            perfilFalho = null;
+        }
+        // O destino de origem e o do pedido novo que abriu o episodio; o despacho do gate completa o que faltar.
+        const origem = (0, runtime_escada_1.destinoDoEpisodio)((0, ledger_1.lerLedger)(dir), plano.fase);
+        const sha = falho.promptSha256;
+        // GO-FIX (achado 10): o caminho do ledger e relativo a quem despachou; o absoluto e o que o dono roda de qualquer lugar.
+        const promptPath = localizarPromptGravado(raiz, threadId, falho.promptPath, sha) ?? falho.promptPath;
+        const despacho = { promptPath, promptSha256: sha, perfil: origem?.perfil ?? perfilFalho,
+            runtime: origem?.runtime ?? (typeof falho.runtime === 'string' ? falho.runtime : carregado.manifesto.runtime.adapter),
+            model: origem?.model ?? (typeof falho.model === 'string' ? falho.model : null),
+            effort: origem?.effort ?? (typeof falho.effort === 'string' ? falho.effort : plano.effort) };
+        // GO-FIX (a conferir da revisao): com o daemon travado, o proprio `claude agents` pode nao responder, e a prova de vida
+        // segurava a escada para sempre. No claude-bg, o degrau 1 reergue o daemon antes (o `--keep-workers` deixa as sessoes
+        // de pe) e a prova e refeita; sem resposta de novo, nada sai, e na terceira vez seguida no episodio o dono e chamado.
+        let daemonJaReerguido = null;
+        if (!viva.respondeu && despacho.runtime === 'claude-bg' && !opcoes.dryRun) {
+            daemonJaReerguido = (0, runtime_escada_1.reerguerDaemon)(opcoes.daemon ?? claude_bg_2.DAEMON_DO_CLAUDE, despacho.perfil);
+            viva = provar(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, ...(sessao ? {} : { semProva: true }),
+                ...(daemonJaReerguido ? { daemon: daemonJaReerguido } : {}) });
+            const seguidas = sessao ? 0 : recusasSemProvaSeguidas((0, ledger_1.lerLedger)(dir), plano.fase);
+            if (seguidas >= exports.LIMITE_SEM_PROVA && !opcoes.dryRun) {
+                const escada = (0, runtime_escada_1.estadoDaEscada)((0, ledger_1.lerLedger)(dir), plano.fase);
+                const motivo = (0, locale_1.textoDoCatalogo)((m) => m.retry.escada.semResposta(seguidas, falhaDaConsulta ?? '-'));
+                return { ...vazio, detalhe: (0, runtime_escada_1.escalarEscada)(carregado, thread, plano.fase, despacho, escada.consumidos, plano.tentativas, plano.limite, motivo) };
+            }
+            return { ...vazio, detalhe };
+        }
+        const saida = (0, runtime_escada_1.subirAEscada)({
+            carregado, thread, fase: plano.fase, despacho,
+            tentativas: plano.tentativas, limite: plano.limite, dryRun: opcoes.dryRun, daemon: opcoes.daemon, daemonJaReerguido,
+            idsConhecidos: ids, provaDeVida: provar,
+            redespachar: (d) => redespachar(carregado, thread, plano.fase, promptPath, sha, { runtime: d.runtime, perfil: d.perfil,
+                model: d.model, effort: d.effort, origem: 'retry.escada', dryRun: opcoes.dryRun }),
+            // RM-055 (D2): a recusa do runtime por um impedimento do dono nao gasta tentativa, tambem na escada.
+            registrarTentativa: (ok, detalhe, extra = {}) => registrarTentativa(ok, detalhe, { ...extra, ...((0, impedimento_1.ehImpedimentoDoDono)(extra.motivoDoRedespacho) ? { conta: false } : {}) }),
+        });
+        return { ...vazio, executada: saida.executada, redespacho: saida.redespacho, detalhe: saida.detalhe };
+    }
+    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,
@@ -1355,7 +1577,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,
@@ -1364,11 +1590,10 @@ function executarRetry(carregado, threadId, opcoes = {}) {
     };
 }
 /**
- * D5 + D11: rotacao depois de falha da conta. Com sessao no gate (o observador classificou a
- * morte), a prova do `ork` decide antes: producao parcial vira `human.pending` com diagnostico.
- * Sem producao, o perfil sai do rodizio e o MESMO prompt segue no proximo destino; recusa da
- * conta no redespacho (nada rodou) continua a rotacao na mesma chamada, dentro do limite de
- * tentativas. Sem destino: fila ate o menor prazo, ou o humano quando nenhum prazo existe.
+ * D5 + RM-064 T2/T3: rotação depois de falha da conta. Produção parcial sob cota segue com um
+ * checkpoint derivado do ledger e do Git; sem produção, o prompt original segue no próximo
+ * destino. Recusa da conta no redespacho continua a rotação dentro do limite de tentativas.
+ * Sem destino: fila até o menor prazo, ou o humano quando nenhum prazo existe.
  */
 function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTentativa) {
     const { raiz, manifesto } = carregado;
@@ -1388,7 +1613,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 };
     }
@@ -1400,18 +1625,21 @@ 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.
+    // RM-064 T3: produção parcial sob cota é preservada no checkpoint; não é razão para recomeçar nem escalar.
+    let checkpoint = false;
     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');
-        }
+        checkpoint = motivo === 'runtime.quota-exhausted' &&
+            (producao.produziu || gate?.origem === 'account.quota-exhausted');
     }
+    const promptOriginalPath = typeof despacho.promptOriginalPath === 'string' ? despacho.promptOriginalPath : despacho.promptPath;
+    const promptOriginalSha = typeof despacho.promptOriginalSha256 === 'string' ? despacho.promptOriginalSha256 : despacho.promptSha256;
     const doBloco = (0, setup_1.configDoBloco)((0, setup_1.lerSetup)(raiz), thread.modo, fase);
-    const fallback = alvosDeFallback(doBloco, doBloco?.runtime ?? manifesto.runtime.adapter);
+    const fallback = alvosDeFallback(doBloco, doBloco?.runtime ?? manifesto.runtime.adapter)
+        .filter(f => (0, runtime_context_1.capacidadeDoRuntimeNoProjeto)(raiz, f.runtime).capaz);
     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.
@@ -1433,7 +1661,7 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
             (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.perfilRotacionado, { fase, motivo: falhaAtual.motivo, origem: 'retry.rotacao',
                 de: { runtime: atual.runtime, perfil: atual.perfil?.id ?? null },
                 para: para ? { runtime: para.runtime, perfil: para.perfil?.id ?? null } : null,
-                evidencia: falhaAtual.trecho, razao, promptSha256: despacho.promptSha256, modo: thread.modo,
+                evidencia: falhaAtual.trecho, razao, promptSha256: promptOriginalSha, modo: thread.modo,
                 autorizadoPor: `politica de retry da I-33 (D5), bloco sem pausa ou delegado no modo ${thread.modo}` });
     };
     for (;;) {
@@ -1442,11 +1670,11 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
             break;
         emitir(alvo, alvo.runtime === atual.runtime ? 'proximo perfil ativo do mesmo runtime' : 'fallback de runtime pela ordem do bloco');
         const mudouRuntime = alvo.runtime !== runtime;
-        ultimo = redespachar(carregado, thread, fase, despacho.promptPath, despacho.promptSha256, {
+        ultimo = redespachar(carregado, thread, fase, promptOriginalPath, promptOriginalSha, {
             runtime: alvo.runtime, perfil: alvo.perfil?.id ?? null,
             model: mudouRuntime ? alvo.model : typeof despacho.model === 'string' ? despacho.model : null,
             effort: mudouRuntime ? alvo.effort ?? (typeof despacho.effort === 'string' ? despacho.effort : null) : plano.effort,
-            origem: 'retry.rotacao', dryRun: opcoes.dryRun,
+            origem: 'retry.rotacao', checkpoint, dryRun: opcoes.dryRun,
         });
         registrarTentativa(ultimo.ok, ultimo.detalhe);
         tentativas += 1;
@@ -1465,8 +1693,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
@@ -1476,24 +1704,25 @@ 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}` };
-    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,
+        return { ...vazio, detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.entrariaNaFila(liberaEm)) };
+    let pedido = (0, ratelimit_1.enfileirar)(carregado, { thread: thread.id, fase, slug: typeof despacho.slug === 'string' ? despacho.slug : (0, phase_1.slugDaSessao)(thread, fase),
+        promptPath: promptOriginalPath, promptSha256: promptOriginalSha,
         cwd: typeof despacho.cwd === 'string' ? despacho.cwd : thread.worktree ?? raiz,
         model: typeof despacho.model === 'string' ? despacho.model : null, effort: typeof despacho.effort === 'string' ? despacho.effort : null,
         sinal: { resetEm: prazo, fonte: prazo ? 'iso' : 'sem-horario', trecho: falhaAtual.trecho },
         detalhe: `${falhaAtual.motivo}: nenhum perfil ativo em ${runtimes.join(', ')}`, runtime, perfil: null, motivo: falhaAtual.motivo });
+    if (checkpoint)
+        pedido = (0, ratelimit_1.gravarPedido)(raiz, { ...pedido, checkpoint: true });
     (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.rateLimitEnfileirado, { fase, slug: pedido.slug, pedido: pedido.id, liberaEm: pedido.liberaEm,
-        janelaEstimada: pedido.janelaEstimada, motivo: falhaAtual.motivo, promptSha256: despacho.promptSha256,
+        janelaEstimada: pedido.janelaEstimada, motivo: falhaAtual.motivo, promptSha256: promptOriginalSha, checkpoint,
         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) {
@@ -1543,14 +1772,16 @@ function destinosQueRecusaramOModelo(eventos, fase) {
  */
 function proximoDestinoDoModelo(raiz, runtime, model, fallback, recusados) {
     const store = (0, runtime_profiles_1.lerPerfisComContas)(raiz);
-    const utilizavel = (p) => !['desativado', 'provider-pago', 'sem-auth'].includes(p.estado) && (0, runtime_profiles_1.perfilDisponivel)(p);
-    const mesmo = (0, runtime_profiles_1.perfisDoRuntime)(store, runtime).find(p => utilizavel(p) && !recusados.has(chaveDoModelo(runtime, p.id, model)));
+    const mesmo = (0, runtime_context_1.capacidadeDoRuntimeNoProjeto)(raiz, runtime).capaz
+        ? (0, runtime_profiles_1.perfisDisponiveis)(store, runtime).find(p => !recusados.has(chaveDoModelo(runtime, p.id, model))) : null;
     if (mesmo)
         return { runtime, perfil: (0, runtime_profiles_1.perfilDeDespacho)(mesmo), model, effort: null };
     for (const f of fallback) {
+        if (!(0, runtime_context_1.capacidadeDoRuntimeNoProjeto)(raiz, f.runtime).capaz)
+            continue;
         const perfis = (0, runtime_profiles_1.perfisDoRuntime)(store, f.runtime);
         if (perfis.length) {
-            const p = perfis.find(x => utilizavel(x) && !recusados.has(chaveDoModelo(f.runtime, x.id, f.model)));
+            const p = (0, runtime_profiles_1.perfisDisponiveis)(store, f.runtime).find(x => !recusados.has(chaveDoModelo(f.runtime, x.id, f.model)));
             if (p)
                 return { runtime: f.runtime, perfil: (0, runtime_profiles_1.perfilDeDespacho)(p), model: f.model, effort: f.effort ?? null };
             continue;
@@ -1561,10 +1792,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
@@ -1591,13 +1822,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'
@@ -1605,18 +1835,19 @@ 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)]);
     const doBloco = (0, setup_1.configDoBloco)((0, setup_1.lerSetup)(raiz), thread.modo, fase);
-    const fallback = alvosDeFallback(doBloco, doBloco?.runtime ?? manifesto.runtime.adapter);
+    const fallback = alvosDeFallback(doBloco, doBloco?.runtime ?? manifesto.runtime.adapter)
+        .filter(f => (0, runtime_context_1.capacidadeDoRuntimeNoProjeto)(raiz, f.runtime).capaz);
     let atual = { runtime, perfil, model };
     let tentativas = plano.tentativas;
     for (;;) {
@@ -1637,8 +1868,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)
@@ -1649,77 +1879,86 @@ 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));
+    // RM-063 (F4): o degrau da escada de `runtime.unavailable`, ou o fim dela.
+    const escada = p.escada;
+    if (escada)
+        linhas.push(escada.degrau && escada.tipo ? m.escada.noPlano(escada.degrau, m.escada.degraus[escada.tipo]) : m.escada.noPlanoEsgotada);
     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');
 }
 /** Texto de `ork retry resume`. */
 function textoDaRetomada(rs) {
+    const m = (0, locale_1.msg)().retry.complementar;
     if (rs.length === 0) {
-        return 'Nenhum pedido da fila de rate limit com a janela liberada agora.';
+        return m.retomadaVazia;
     }
     const linhas = [];
     for (const r of rs) {
-        linhas.push(`${r.pedido.id}  thread ${r.pedido.thread}  fase ${r.pedido.fase}`);
-        linhas.push(`  playbook    ${r.playbook}`);
-        linhas.push(`  slug        ${r.slug}`);
-        linhas.push(`  retomada    ${r.despachada ? `sim (sessao ${r.sessionId})` : 'nao'}`);
+        linhas.push(m.retomadaCabecalho(r.pedido.id, r.pedido.thread, r.pedido.fase));
+        linhas.push(m.playbook(r.playbook));
+        linhas.push(m.slug(r.slug));
+        linhas.push(m.retomada(r.despachada, r.sessionId));
         if (r.motivo)
-            linhas.push(`  motivo      ${r.motivo}`);
-        linhas.push(`  detalhe     ${(0, horario_1.localizarTexto)(r.detalhe)}`);
-        linhas.push(`  estado      ${r.pedido.estado}`);
+            linhas.push(m.motivoRetomada(r.motivo));
+        linhas.push(m.detalhe((0, horario_1.localizarTexto)(r.detalhe)));
+        linhas.push(m.estado(m.estados[r.pedido.estado] ?? r.pedido.estado));
     }
     if (rs.some((r) => (0, horario_1.localizarTexto)(r.detalhe) !== r.detalhe))
         linhas.push((0, horario_1.legendaDoFuso)());