@orkastery/cli 0.5.6 → 0.6.1

package/dist/retry.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TETO_DO_PROMPT_GRAVADO = 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;
@@ -55,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;
@@ -90,12 +91,15 @@ 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");
 const policies_1 = require("./policies");
 const ratelimit_1 = require("./ratelimit");
 const session_watcher_claude_1 = require("./session-watcher-claude");
+const session_watcher_grok_1 = require("./session-watcher-grok");
 const runtime_profiles_1 = require("./runtime-profiles");
 const modos_1 = require("./modos");
 const thread_1 = require("./thread");
@@ -112,6 +116,7 @@ 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;
 /**
@@ -228,10 +233,9 @@ exports.POLITICA_DE_RETRY = {
         automatica: true,
         ...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',
@@ -317,13 +321,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) {
@@ -353,8 +359,12 @@ function ultimaReprovacao(raiz, threadId) {
  * planejou: planejar nao gasta janela nem toca no repositorio.
  */
 function tentativasFeitas(raiz, threadId, fase, motivo) {
+    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 (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;
+    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) {
@@ -417,6 +427,17 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
             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.
     if (tentativas >= limite) {
         return {
@@ -439,7 +460,8 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
     // 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;
@@ -450,6 +472,10 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
     let bloqueio = null;
     let automatica = politica.automatica;
     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)));
     }
@@ -476,7 +502,7 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
     }
     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. */
@@ -606,8 +632,8 @@ tomadaPrevia) {
             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,
@@ -617,6 +643,10 @@ tomadaPrevia) {
             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);
@@ -630,7 +660,8 @@ 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)`,
+            ...(opcoes.perfilPedido ? { perfilPedido: opcoes.perfilPedido } : {}),
         });
         return { ...vazio, ok: false, motivo, detalhe, dryRun: opcoes.dryRun === true };
     }
@@ -641,7 +672,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) {
@@ -658,7 +689,7 @@ 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);
@@ -677,8 +708,9 @@ tomadaPrevia) {
         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: e.message, dryRun: opcoes.dryRun === true };
+            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
@@ -711,22 +743,27 @@ tomadaPrevia) {
             }
             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) {
-                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;
+        try {
+            contextoRuntime = (0, runtime_context_1.contextoDoProjeto)(raiz, runtime, cwd, thread.id);
+        }
+        catch (e) {
+            const erro = e.message;
+            if (!opcoes.dryRun && opcoes.perfilPedido)
+                (0, gates_1.registrarGateBloqueado)((0, thread_1.dirThread)(raiz, thread.id), thread.id, {
+                    gate: 'phase.dispatch', motivo: 'runtime.unavailable', modo: thread.modo,
+                    detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.perfilPedidoRecusado(opcoes.perfilPedido.id, opcoes.perfilPedido.runtime, 'runtime.unavailable', erro)),
+                    correcao: (0, locale_1.textoDoCatalogo)((m) => m.retry.correcaoDoPerfilPedido(opcoes.perfilPedido.id, opcoes.perfilPedido.runtime, 'runtime.unavailable', thread.id)),
+                    fase, slug, origem: opcoes.origem ?? 'retry', promptPath: promptExecutadoPath,
+                    promptSha256: promptExecutadoSha, perfilPedido: opcoes.perfilPedido,
+                });
+            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 {
@@ -739,12 +776,23 @@ tomadaPrevia) {
         if (escolha.erro) {
             const motivo = escolha.motivo ?? 'runtime.unavailable';
             const prazo = motivo === 'runtime.quota-exhausted' ? (0, runtime_profiles_1.prazoDoRuntime)((0, runtime_profiles_1.lerPerfisComContas)(raiz), runtime, (0, runtime_profiles_1.politicaDeRotacao)(manifesto)) : null;
-            return { ...vazio, ok: false, motivo, detalhe: `${motivo}: ${escolha.erro}`, dryRun: opcoes.dryRun === true,
+            const detalhe = opcoes.perfilPedido
+                ? (0, locale_1.textoDoCatalogo)((m) => m.retry.perfilPedidoRecusado(opcoes.perfilPedido.id, opcoes.perfilPedido.runtime, motivo, escolha.erro))
+                : `${motivo}: ${escolha.erro}`;
+            if (!opcoes.dryRun && opcoes.perfilPedido)
+                (0, gates_1.registrarGateBloqueado)((0, thread_1.dirThread)(raiz, thread.id), thread.id, {
+                    gate: 'phase.dispatch', motivo, modo: thread.modo, detalhe,
+                    correcao: (0, locale_1.textoDoCatalogo)((m) => m.retry.correcaoDoPerfilPedido(opcoes.perfilPedido.id, opcoes.perfilPedido.runtime, motivo, thread.id)), fase, slug, origem: opcoes.origem ?? 'retry',
+                    promptPath: promptExecutadoPath, promptSha256: promptExecutadoSha, perfilPedido: opcoes.perfilPedido,
+                });
+            return { ...vazio, ok: false, motivo, detalhe, dryRun: opcoes.dryRun === true,
                 sinal: prazo ? { resetEm: prazo, fonte: 'iso', trecho: `menor esgotadoAte dos perfis ${runtime}` } : null };
         }
         const perfil = escolha.perfil ?? undefined;
-        // I-33 (N1): o HEAD do GO codex sai antes do despacho, como no `ork phase run`.
-        const headNoDespacho = fase === 'GO' && runtime === 'codex' && !opcoes.dryRun ? (0, session_watcher_claude_1.headDaWorktree)(cwd) : undefined;
+        // I-33 (N1): o HEAD do GO codex sai antes do despacho, como no `ork phase run`. RM-067: o grok tambem.
+        const headNoDespacho = fase === 'GO' && (runtime === 'codex' || runtime === 'grok') && !opcoes.dryRun ? (0, session_watcher_claude_1.headDaWorktree)(cwd) : undefined;
+        // RM-067 (D8): a base do artefato do grok tambem sai antes do redespacho, como no `ork phase run`.
+        const artefatoNoDespacho = runtime === 'grok' && !opcoes.dryRun ? (0, session_watcher_grok_1.baseDoArtefato)(raiz, thread.id, fase) : undefined;
         const resultado = rt.despachar({
             prompt,
             nome: slug,
@@ -754,10 +802,12 @@ 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,
+            // RM-067 (GO-FIX 1, A3): o grok tambem; no PLAN que fecha o bloco, ele roda em read-only.
+            ...((runtime === 'claude-bg' || runtime === 'grok') && (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),
         });
@@ -775,15 +825,21 @@ tomadaPrevia) {
             };
         }
         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 } : {}), ...(opcoes.perfilPedido ? { perfilPedido: opcoes.perfilPedido } : {}), ...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,
@@ -800,7 +856,7 @@ 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'),
@@ -822,27 +878,33 @@ tomadaPrevia) {
             thread,
             fase,
             slug,
-            promptPath: absoluto,
-            promptSha256: sha,
+            promptPath: promptExecutadoPath,
+            promptSha256: promptExecutadoSha,
+            ...(retomada ? { promptOriginal: { path: absoluto, sha256: sha } } : {}),
             runtime,
             cwd,
             model,
             effort,
             origem: opcoes.origem ?? 'retry',
             ...(perfil ? { perfil } : {}),
+            ...(opcoes.perfilPedido ? { perfilPedido: opcoes.perfilPedido } : {}),
             ...(headNoDespacho !== undefined ? { headNoDespacho } : {}),
+            ...(artefatoNoDespacho !== undefined ? { artefatoNoDespacho } : {}),
         };
-        (0, phase_1.concluirDespacho)(ctx, resultado.sessionId, resultado.verificada, resultado.comando, rt.fonteVerificacao, resultado.controlador);
+        // RM-067 (D14 da ork-grokbuild): o redespacho do grok leva os sensores do supervisor ao registro do watcher; o caminho
+        // do codex e do claude-bg segue sem eles, como antes.
+        (0, phase_1.concluirDespacho)(ctx, resultado.sessionId, resultado.verificada, resultado.comando, rt.fonteVerificacao, resultado.controlador, runtime === 'grok' ? { logPath: resultado.logPath, processoPath: resultado.processoPath, reciboPath: resultado.reciboPath } : undefined);
         return {
             ok: true,
             slug,
             sessionId: resultado.sessionId,
             verificada: resultado.verificada,
             motivo: null,
-            detalhe: (0, locale_1.textoDoCatalogo)((m) => m.retry.redespachada(String(resultado.sessionId), sha.slice(0, 12), perfil ? perfil.id : null, 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,
         };
     }
@@ -895,6 +957,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;
@@ -969,10 +1040,12 @@ function retomarPedido(carregado, pedidoOriginal, opcoes = {}) {
             slug,
             runtime: alvo.runtime,
             perfil: alvo.perfil ?? doPedido.perfil ?? null,
+            ...(doPedido.perfilPedido ? { perfilPedido: doPedido.perfilPedido } : {}),
             model: alvo.model,
             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, {
@@ -1078,13 +1151,18 @@ function retomarPedido(carregado, pedidoOriginal, opcoes = {}) {
 function alvoDaRetomada(carregado, thread, pedido) {
     const { raiz, manifesto } = carregado;
     const original = { runtime: pedido.runtime ?? null, model: pedido.model, effort: pedido.effort };
+    if (pedido.perfilPedido)
+        return { runtime: pedido.perfilPedido.runtime, perfil: pedido.perfilPedido.id,
+            model: pedido.model, effort: pedido.effort, destino: true, runtimes: [pedido.perfilPedido.runtime], contas: false };
     if (pedido.motivo !== 'runtime.quota-exhausted' && pedido.motivo !== 'runtime.auth-missing')
         return { ...original, destino: true, runtimes: original.runtime ? [original.runtime] : [], contas: false };
     const doBloco = (0, setup_1.configDoBloco)((0, setup_1.lerSetup)(raiz), thread.modo, pedido.fase);
     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 }))]
+        // RM-067 (F4): a troca de conta do runtime principal vale tambem para o runtime sem host MCP (o grok).
+        .filter(c => (0, runtime_context_1.capacidadeDaRotacao)(raiz, c.runtime, c.runtime === principal).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) {
@@ -1145,11 +1223,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.capacidadeDaRotacao)(raiz, atual.runtime, true).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 });
@@ -1220,6 +1299,41 @@ function despachoDaFalha(eventos, gate, fase) {
 function perfilDoEvento(e) {
     return e && e.perfil !== undefined && e.perfil !== null ? (0, runtime_profiles_1.validarPerfilDeDespacho)(e.perfil) : null;
 }
+/** O marcador distinto do destino efetivo: ausente em despacho sem `--perfil` e em rotacao interna. */
+function perfilPedidoDoEvento(e) {
+    if (!e || e.perfilPedido === undefined || e.perfilPedido === null)
+        return null;
+    if (typeof e.perfilPedido !== 'object' || Array.isArray(e.perfilPedido))
+        return null;
+    const p = e.perfilPedido;
+    if (typeof p.runtime !== 'string' || p.runtime.length === 0 || p.runtime.length > 64)
+        return null;
+    try {
+        return { id: (0, runtime_profiles_1.validarIdDePerfil)(p.id), runtime: p.runtime };
+    }
+    catch {
+        return null;
+    }
+}
+/** Recupera o pedido do mesmo prompt; eventos antigos sem o campo preservam o comportamento anterior. */
+function perfilPedidoDoDespacho(eventos, fase, despacho, gate) {
+    for (const e of [gate, despacho]) {
+        const p = perfilPedidoDoEvento(e);
+        if (p)
+            return p;
+    }
+    const sha = typeof despacho?.promptSha256 === 'string' ? despacho.promptSha256
+        : typeof gate?.promptSha256 === 'string' ? gate.promptSha256 : null;
+    for (let i = eventos.length - 1; i >= 0; i--) {
+        const e = eventos[i];
+        if (e.fase !== fase || (sha !== null && e.promptSha256 !== sha))
+            continue;
+        const p = perfilPedidoDoEvento(e);
+        if (p)
+            return p;
+    }
+    return null;
+}
 /** O perfil ja esta fora do rodizio por esta falha (cota com prazo futuro, ou sem login)? */
 function jaMarcado(raiz, perfil, falha, agoraMs = Date.now()) {
     let atual;
@@ -1263,6 +1377,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.
  *
@@ -1308,6 +1441,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, {
@@ -1372,7 +1527,8 @@ function executarRetry(carregado, threadId, opcoes = {}) {
     }
     if (acaoBase === 'sincronizar-worktree') {
         const sync = (0, worktree_1.sincronizarWorktree)(carregado, threadId, { dryRun: opcoes.dryRun });
-        const detalhe = (0, locale_1.textoDoCatalogo)((m) => sync.ok ? m.retry.sincronizada(sync.passos.join('; ')) : m.retry.sincronizacaoFalhou(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 };
     }
@@ -1386,7 +1542,29 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         registrarTentativa(rodada.correcoes.length > 0, detalhe);
         return { ...vazio, executada: rodada.correcoes.length > 0, rodada, reverify, detalhe };
     }
+    const redespacharNoPerfilPedido = (falho, pedido) => {
+        const r = redespachar(carregado, thread, plano.fase, String(falho.promptPath), String(falho.promptSha256), {
+            runtime: pedido.runtime,
+            perfil: pedido.id,
+            perfilPedido: pedido,
+            model: typeof falho.model === 'string' ? falho.model : null,
+            effort: plano.effort ?? (typeof falho.effort === 'string' ? falho.effort : null),
+            origem: 'retry.run',
+            dryRun: opcoes.dryRun,
+        });
+        registrarTentativa(r.ok, r.detalhe, { perfilPedido: pedido, ...(!r.ok ? { conta: false } : {}) });
+        return { ...vazio, executada: r.ok, redespacho: r, detalhe: r.detalhe };
+    };
     if (plano.motivo === 'runtime.quota-exhausted' || plano.motivo === 'runtime.auth-missing') {
+        const eventos = (0, ledger_1.lerLedger)(dir);
+        const gate = ultimaReprovacao(raiz, threadId);
+        const falho = despachoParaRedespachar(eventos, plano.fase, gate);
+        const pedido = perfilPedidoDoDespacho(eventos, plano.fase, falho, gate);
+        // Falha observada na propria conta continua na rotacao I-33 D5/RM-064 T3. A indisponibilidade
+        // detectada antes de abrir a conta preserva o pedido do dono e nunca escolhe outra em silencio.
+        if (pedido && gate?.falhaDeConta === undefined && falho && typeof falho.promptPath === 'string' &&
+            typeof falho.promptSha256 === 'string')
+            return redespacharNoPerfilPedido(falho, pedido);
         return rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTentativa);
     }
     if (plano.motivo === 'runtime.model-unavailable') {
@@ -1403,6 +1581,7 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         registrarTentativa(false, detalhe);
         return { ...vazio, detalhe };
     }
+    const perfilPedidoDoRetry = perfilPedidoDoDespacho((0, ledger_1.lerLedger)(dir), plano.fase, falho, gateDoPlano);
     // 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') {
@@ -1419,7 +1598,63 @@ function executarRetry(carregado, threadId, opcoes = {}) {
     // 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);
+    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 perfilPedido = perfilPedidoDoDespacho((0, ledger_1.lerLedger)(dir), plano.fase, falho, gateDoPlano);
+        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 };
+        }
+        if (perfilPedido)
+            return redespacharNoPerfilPedido(falho, perfilPedido);
+        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))
@@ -1429,8 +1664,9 @@ function executarRetry(carregado, threadId, opcoes = {}) {
     }
     const redespacho = redespachar(carregado, thread, plano.fase, falho.promptPath, falho.promptSha256, {
         effort: plano.effort,
-        runtime: typeof falho.runtime === 'string' ? falho.runtime : null,
+        runtime: perfilPedidoDoRetry?.runtime ?? (typeof falho.runtime === 'string' ? falho.runtime : null),
         model: typeof falho.model === 'string' ? falho.model : null,
+        ...(perfilPedidoDoRetry ? { perfil: perfilPedidoDoRetry.id, perfilPedido: perfilPedidoDoRetry } : {}),
         origem: 'retry.run',
         dryRun: opcoes.dryRun,
     });
@@ -1447,11 +1683,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;
@@ -1486,15 +1721,18 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
         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', (0, locale_1.textoDoCatalogo)((m) => m.retry.producaoParcialConta(motivo === 'runtime.quota-exhausted', String(producao.evidencia))));
-        }
+        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.
@@ -1516,7 +1754,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 (;;) {
@@ -1525,11 +1763,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;
@@ -1565,14 +1803,16 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
     emitir(null, `nenhum perfil ativo em ${runtimes.join(', ')}: fila duravel ate ${liberaEm}`);
     if (opcoes.dryRun)
         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,
+    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: (0, locale_1.textoDoCatalogo)((m) => m.retry.pedidoAte(pedido.id, pedido.liberaEm)) };
@@ -1625,14 +1865,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.capacidadeDaRotacao)(raiz, runtime, true).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;
@@ -1697,7 +1939,8 @@ function trocarDestinoDoModelo(carregado, thread, plano, opcoes, vazio, registra
     }
     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 (;;) {
@@ -1753,6 +1996,10 @@ function textoDoPlano(p) {
     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(m.bloqueio(p.bloqueio));
     linhas.push(m.razao((0, locale_1.remontar)(p.razao)));
@@ -1791,19 +2038,20 @@ function textoDoRetry(r) {
 }
 /** 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)());