@orkastery/cli 0.4.2 → 0.5.0

package/dist/pulse.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JANELA_DAS_DECISOES_MS = exports.CONTRATO_PULSE = void 0;
+exports.apresentacaoCurtaDoItem = apresentacaoCurtaDoItem;
 exports.comporPulse = comporPulse;
 exports.montarPulse = montarPulse;
 exports.textoDoPulse = textoDoPulse;
@@ -20,6 +21,7 @@ const util_1 = require("./util");
 const horario_1 = require("./horario");
 const hitl_presentation_1 = require("./hitl-presentation");
 const hitl_contract_1 = require("./hitl-contract");
+const hitl_curto_1 = require("./hitl-curto");
 const decisao_autonoma_1 = require("./decisao-autonoma");
 const docs_1 = require("./docs");
 const conducao_1 = require("./conducao");
@@ -30,6 +32,18 @@ exports.JANELA_DAS_DECISOES_MS = 7 * 24 * 60 * 60 * 1000;
 const impacto = (fase) => types_1.FASES.indexOf(fase) + 1;
 const ordenar = (a, b) => (b.paradaHaMin ?? -1) - (a.paradaHaMin ?? -1) || b.impacto - a.impacto || a.id.localeCompare(b.id);
 const minutos = (desde, quando) => desde && Number.isFinite(Date.parse(desde)) ? Math.max(0, Math.floor((Date.parse(quando) - Date.parse(desde)) / 60000)) : null;
+/**
+ * RM-048 (D1 e D4): o texto curto de uma pergunta v2 de gate e a linha com o codigo estavel.
+ * Pedido sem codigo (v1, sessao) continua com o comando de antes: nada e inventado para ele.
+ */
+function apresentacaoCurtaDoItem(pedido, desde, quando) {
+    if (!(0, hitl_contract_1.ehV2)(pedido) || pedido.classe !== 'pergunta' || pedido.alvo.tipo !== 'gate')
+        return undefined;
+    const curto = (0, hitl_curto_1.montarPedidoCurto)((0, hitl_curto_1.entradaDoPedido)(pedido, desde ?? pedido.criadoEm), { quando, responder: { tipo: 'codigo', codigo: pedido.codigo } });
+    const recomendada = pedido.alternativas.find(a => a.recomendada)?.letra ?? 'a';
+    return { textos: { telegram: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'telegram'), terminal: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'terminal') },
+        comando: `${pedido.codigo} ${recomendada}` };
+}
 function comporPulse(carregado, entrada) {
     const { radar, monitor, batch, orfas } = entrada, quando = radar.consultadoEm;
     const humanos = [], automaticas = [];
@@ -186,6 +200,13 @@ function comporPulse(carregado, entrada) {
                 item.opcoes = (0, hitl_contract_1.escolhasDoPedido)(pedido).map(o => `${(0, hitl_contract_1.chaveDaEscolha)(pedido, o.numero)}. ${o.texto}`);
                 item.recomendacao = (0, hitl_contract_1.recomendacaoDoPedido)(pedido);
                 item.comandoResposta = `/ork ${(0, hitl_contract_1.alvoDoPedido)(pedido)?.tipo === 'session' ? 'session' : 'gate'} ${pedido.thread} ${pedido.id} <resposta>`;
+                // RM-048 (D1 e D4): a pergunta v2 de gate sai pelo contrato curto, e a linha que o dono
+                // recebe e o codigo estavel ("DE6H a"), nao o identificador que muda a cada renovacao.
+                const curta = apresentacaoCurtaDoItem(pedido, item.desdeEm, quando);
+                if (curta) {
+                    item.apresentacaoCurta = curta.textos;
+                    item.comandoResposta = curta.comando;
+                }
                 // O Pulse nao e uma conexao MCP: nenhum canal mcp-local sai `disponivel` daqui.
                 item.canais = (0, hitl_presentation_1.ofertaDoPedido)(pedido);
             }

package/dist/ratelimit.js

@@ -144,7 +144,7 @@ function enfileirar(carregado, novo, agoraMs = Date.now()) {
  * ela, a janela padrao do manifesto (estimativa declarada, nunca chute). Auth ausente: sem prazo.
  */
 function prazoDaConta(manifesto, falha, agoraMs = Date.now()) {
-    if (falha.motivo === 'runtime.auth-missing')
+    if (falha.motivo !== 'runtime.quota-exhausted')
         return null;
     // A10: horario dito que ja passou nao devolve o perfil ao rodizio na hora: vale a janela padrao.
     if (falha.resetEm !== null && Date.parse(falha.resetEm) > agoraMs)
@@ -153,7 +153,8 @@ function prazoDaConta(manifesto, falha, agoraMs = Date.now()) {
 }
 /** Marca no store o perfil que falhou pela conta. Sem perfil (ambiente do processo), nada a marcar. */
 function marcarContaDaFalha(carregado, perfil, falha, agoraMs = Date.now()) {
-    if (!perfil)
+    // RM-037 (defeitosdeco D-6): modelo inacessivel nao e falha da conta inteira; o perfil fica no rodizio.
+    if (!perfil || falha.motivo === 'runtime.model-unavailable')
         return null;
     const esgotado = falha.motivo === 'runtime.quota-exhausted';
     return (0, runtime_profiles_1.marcarFalhaDePerfil)(carregado.raiz, perfil.id, { estado: esgotado ? 'esgotado' : 'sem-auth',

package/dist/retry.js

@@ -93,6 +93,7 @@ const policies_1 = require("./policies");
 const ratelimit_1 = require("./ratelimit");
 const session_watcher_claude_1 = require("./session-watcher-claude");
 const runtime_profiles_1 = require("./runtime-profiles");
+const modos_1 = require("./modos");
 const thread_1 = require("./thread");
 const tokens_1 = require("./tokens");
 const util_1 = require("./util");
@@ -241,6 +242,15 @@ exports.POLITICA_DE_RETRY = {
         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',
     },
+    // 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.
+    'runtime.model-unavailable': {
+        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',
+    },
     'tree.blocked': {
         motivo: 'tree.blocked',
         acao: 'sincronizar-worktree',
@@ -472,10 +482,29 @@ function escalarEsforco(base, degraus) {
  *     de provider pago enquanto a fase esperava, a retomada recusa em vez de gastar.
  */
 function redespachar(carregado, thread, fase, promptRelativo, sha, opcoes = {}) {
-    const run = () => redespacharSobLock(carregado, (0, thread_1.lerThread)(carregado.raiz, thread.id), fase, promptRelativo, sha, opcoes);
-    return opcoes.dryRun ? run() : (0, hitl_gates_1.comLockHitl)(carregado.raiz, thread.id, run);
+    const run = (retida) => redespacharSobLock(carregado, (0, thread_1.lerThread)(carregado.raiz, thread.id), fase, promptRelativo, sha, opcoes, retida);
+    if (opcoes.dryRun)
+        return run();
+    // RM-037 (defeito 1; A2, G1 e N3 do CHECK 1 e 2, B-1 e A-1r do CHECK 4): o fallback do bloco leva a
+    // retomada ao codex. O redespacho pede a baseline depois das guardas baratas, RETENDO a conducao tomada; ela
+    // e gravada aqui, fora do lock HITL, como reentrada dessa tomada, e a retomada repete uma vez com ela.
+    const r = (0, hitl_gates_1.comLockHitl)(carregado.raiz, thread.id, () => run());
+    const retida = r.retida;
+    if (!retida)
+        return r;
+    delete r.retida;
+    try {
+        (0, phase_1.garantirBaselineDoDespacho)(carregado, thread.id, { fase, prompt: '', runtime: opcoes.runtime ?? undefined,
+            model: opcoes.model ?? undefined, effort: opcoes.effort ?? undefined, ...(opcoes.canal ? { canal: opcoes.canal } : {}) }, retida.identidade);
+        return (0, hitl_gates_1.comLockHitl)(carregado.raiz, thread.id, () => run(retida));
+    }
+    finally {
+        retida.devolver();
+    }
 }
-function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes = {}) {
+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
@@ -526,13 +555,24 @@ function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes
     // I-36 (T6): validado o pedido, a retomada toma a conducao antes de redespachar, como o
     // `ork phase run`. A mesma fase com o mesmo prompt de quem ja conduz nao abre sessao nova;
     // outro pedido espera a vez.
-    const identidade = (0, runtime_context_1.novaIdentidadeDeDespacho)(thread.id, fase);
+    const identidade = tomadaPrevia ? { ...(0, runtime_context_1.novaIdentidadeDeDespacho)(thread.id, fase), dispatchId: tomadaPrevia.identidade }
+        : (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,
         identidade: identidade.dispatchId, prazoMs: (0, phase_1.prazoDaSessao)(doBlocoDaConducao) };
     let conducao = null;
-    if (!opcoes.dryRun) {
+    if (tomadaPrevia) {
+        // R5-B1 do CHECK 5: a sucedida que o dono respondeu durante a baseline recebe o lease de volta.
+        if (!tomadaPrevia.sucessaoAindaVale()) {
+            tomadaPrevia.devolver();
+            const recusa = (0, conducao_1.recusaDeConducao)(thread.id, (0, conducao_1.conducaoDaThread)(raiz, thread.id), pedidoDeConducao);
+            (0, conducao_1.registrarRecusa)(raiz, recusa);
+            return { ...vazio, ok: false, motivo: 'conducao.em-andamento', detalhe: recusa.texto, dryRun: false };
+        }
+        conducao = tomadaPrevia;
+    }
+    else if (!opcoes.dryRun) {
         const tomada = (0, conducao_1.tomarConducao)(raiz, thread.id, pedidoDeConducao);
         if (!tomada.ok) {
             if (tomada.idempotente && tomada.atual) {
@@ -561,6 +601,17 @@ function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes
             effort: opcoes.effort ?? undefined,
         }, doBloco);
         const rt = (0, runtimes_1.resolverRuntime)(runtime);
+        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` };
+            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.
@@ -605,7 +656,8 @@ function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes
             logDir: path.join((0, thread_1.dirThread)(raiz, thread.id), 'sessoes'),
             vinculo: { thread: thread.id, fase, promptSha256: sha },
             ...(perfil ? { perfil } : {}),
-            ...(runtime === 'claude-bg' ? { contextoRuntime, ...(fase === 'PLAN' ? { colaboracao: 'plan' } : {}) } : {}),
+            // 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' } : {}) } : {}),
             // 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),
         });
@@ -685,8 +737,9 @@ function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes
         };
     }
     finally {
-        // Retomada que nao virou sessao devolve a conducao; a que virou ja a entregou a sessao.
-        conducao?.liberar();
+        // Retomada que nao virou sessao devolve a conducao, com o que a tomada consumiu; a que virou ja a
+        // entregou a sessao, e devolver entao nao faz nada.
+        conducao?.devolver();
     }
 }
 // ---------------------------------------------------------------------------
@@ -1218,6 +1271,9 @@ function executarRetry(carregado, threadId, opcoes = {}) {
     if (plano.motivo === 'runtime.quota-exhausted' || plano.motivo === 'runtime.auth-missing') {
         return rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTentativa);
     }
+    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');
     if (!falho || typeof falho.promptPath !== 'string' || typeof falho.promptSha256 !== 'string') {
@@ -1337,7 +1393,10 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
         else
             implicitos.push(alvo.runtime);
         atual = { runtime: alvo.runtime, perfil: alvo.perfil };
-        falhaAtual = ultimo.falhaDeConta ?? falhaAtual;
+        // GO-FIX (R4b): destino que recusou o MODELO sai da rotacao, mas a falha que manda (e o motivo da
+        // fila) continua sendo a da conta; o modelo inacessivel tem troca propria (trocarDestinoDoModelo).
+        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`);
@@ -1369,6 +1428,168 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
     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}` };
 }
+/** RM-037 (defeitosdeco D-6): chave de um destino (runtime, perfil, modelo) que recusou o modelo. */
+function chaveDoModelo(runtime, perfil, model) {
+    return `${runtime}|${perfil ?? ''}|${model ?? ''}`;
+}
+/**
+ * D-6: todo destino que ja recusou o modelo nesta fase, lido do ledger. O gate do observador traz o
+ * `sessionId` (o modelo vem do `phase_dispatch` dele); o do despacho sincrono, o ultimo
+ * `phase_dispatch_failed` da fase antes dele.
+ */
+function destinosQueRecusaramOModelo(eventos, fase) {
+    const chaves = [];
+    const chaveDo = (origem) => {
+        if (typeof origem.runtime !== 'string')
+            return null;
+        let perfil = null;
+        try {
+            perfil = perfilDoEvento(origem);
+        }
+        catch { /* perfil ilegivel nao exclui ninguem */ }
+        return chaveDoModelo(origem.runtime, perfil?.id ?? null, typeof origem.model === 'string' ? origem.model : null);
+    };
+    eventos.forEach((e, i) => {
+        // GO-FIX (R4a): a recusa sincrona do redespacho (nada rodou) so grava `phase_dispatch_failed`.
+        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou && e.fase === fase && String(e.erro ?? '').startsWith('runtime.model-unavailable')) {
+            const chave = chaveDo(e);
+            if (chave)
+                chaves.push(chave);
+            return;
+        }
+        if (e.tipo !== ledger_1.TIPOS_DE_EVENTO.gateBloqueado || e.fase !== fase || e.motivo !== 'runtime.model-unavailable')
+            return;
+        const origem = typeof e.sessionId === 'string'
+            ? eventos.filter(d => d.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada && d.sessionId === e.sessionId).at(-1)
+            : eventos.slice(0, i).filter(d => d.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou && d.fase === fase).at(-1);
+        const chave = origem ? chaveDo(origem) : null;
+        if (chave)
+            chaves.push(chave);
+    });
+    return chaves;
+}
+/**
+ * D-6: o proximo destino do MESMO prompt depois de `runtime.model-unavailable`. Primeiro outro perfil do
+ * mesmo runtime com o MESMO modelo (outra conta pode ter acesso), depois cada runtime da ordem de
+ * fallback do bloco com o modelo dele. Perfil fora do rodizio (esgotado, sem login, desativado, pago)
+ * nao entra, e nenhum destino que ja recusou volta. Sem destino, `null`.
+ */
+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)));
+    if (mesmo)
+        return { runtime, perfil: (0, runtime_profiles_1.perfilDeDespacho)(mesmo), model, effort: null };
+    for (const f of fallback) {
+        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)));
+            if (p)
+                return { runtime: f.runtime, perfil: (0, runtime_profiles_1.perfilDeDespacho)(p), model: f.model, effort: f.effort ?? null };
+            continue;
+        }
+        if (!recusados.has(chaveDoModelo(f.runtime, null, f.model)))
+            return { runtime: f.runtime, perfil: null, model: f.model, effort: f.effort ?? null };
+    }
+    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) {
+    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`;
+}
+/**
+ * RM-037 (defeitosdeco D-6): troca de destino depois de `runtime.model-unavailable`. O modelo pedido nao
+ * existe ou a conta nao tem acesso a ele (`model_not_found` na transcricao); o perfil continua no
+ * rodizio e o MESMO prompt segue no proximo destino (`proximoDestinoDoModelo`). Producao no intervalo
+ * escala ao humano, como na rotacao por conta. Recusa do modelo no redespacho (nada rodou) continua a
+ * troca na mesma chamada, dentro do limite de tentativas. Sem destino, o humano recebe a correcao exata.
+ */
+function trocarDestinoDoModelo(carregado, thread, plano, opcoes, vazio, registrarTentativa) {
+    const { raiz, manifesto } = carregado;
+    const dir = (0, thread_1.dirThread)(raiz, thread.id);
+    const fase = plano.fase;
+    const motivo = 'runtime.model-unavailable';
+    const eventos = (0, ledger_1.lerLedger)(dir);
+    const gate = ultimaReprovacao(raiz, thread.id);
+    const despacho = despachoDaFalha(eventos, gate, fase);
+    const escalar = (razao, diagnostico) => {
+        if (!opcoes.dryRun) {
+            (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: 'human.pending', modo: thread.modo, detalhe: diagnostico,
+                diagnostico, correcao: `ork gate request ${thread.id}`, fase, origem: 'retry.modelo', pausaQualquerModo: true });
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.retryEscalado, { fase, motivo, origem: 'retry.modelo', acao: plano.acao,
+                tentativas: plano.tentativas, limite: plano.limite, modo: thread.modo, razao });
+        }
+        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`;
+        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'
+            ? (0, runtime_profiles_1.perfilDoRegistro)(eventos, { sessionId: gate.sessionId, despachadaEm: typeof gate.despachoEm === 'string' ? gate.despachoEm : undefined })
+            : perfilDoEvento(despacho);
+    }
+    catch (e) {
+        return escalar('perfil registrado invalido', `troca de destino recusada: ${e.message}`);
+    }
+    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');
+        }
+    }
+    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);
+    let atual = { runtime, perfil, model };
+    let tentativas = plano.tentativas;
+    for (;;) {
+        const alvo = proximoDestinoDoModelo(raiz, runtime, model, fallback, recusados);
+        if (!alvo)
+            break;
+        if (!opcoes.dryRun)
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.perfilRotacionado, { fase, motivo, origem: 'retry.modelo',
+                de: { runtime: atual.runtime, perfil: atual.perfil?.id ?? null, model: atual.model },
+                para: { runtime: alvo.runtime, perfil: alvo.perfil?.id ?? null, model: alvo.model },
+                razao: alvo.runtime === runtime ? 'outro perfil do mesmo runtime com o mesmo modelo' : 'fallback de runtime pela ordem do bloco',
+                promptSha256: despacho.promptSha256, modo: thread.modo,
+                autorizadoPor: `politica de retry da RM-037 (D-6), bloco sem pausa ou delegado no modo ${thread.modo}` });
+        const mudouRuntime = alvo.runtime !== runtime;
+        const r = redespachar(carregado, thread, fase, despacho.promptPath, despacho.promptSha256, {
+            runtime: alvo.runtime, perfil: alvo.perfil?.id ?? null, model: alvo.model,
+            effort: mudouRuntime ? alvo.effort ?? (typeof despacho.effort === 'string' ? despacho.effort : null) : plano.effort,
+            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}` };
+        registrarTentativa(r.ok, r.detalhe);
+        tentativas += 1;
+        if (r.ok)
+            return { ...vazio, executada: true, redespacho: r, detalhe: r.detalhe };
+        // So a recusa do MODELO no redespacho (nada rodou) continua a troca; outra falha para aqui.
+        if (r.falhaDeConta?.motivo !== 'runtime.model-unavailable')
+            return { ...vazio, redespacho: r, detalhe: r.detalhe };
+        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 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)}`);
+}
 /** Texto de `ork retry plan`. */
 function textoDoPlano(p) {
     const linhas = [];