@orkastery/cli 0.2.0 → 0.3.0

package/dist/retry.js

@@ -1,24 +1,4 @@
 "use strict";
-/**
- * Politica de retry TIPADA e retomada automatica (bloco B3).
- *
- * O B1 deu ao `ork` o MOTIVO tipado de cada reprovacao; o B2 deu a thread um estado
- * retomavel em disco. O B3 e a camada que liga os dois: para cada motivo tipado existe
- * UMA acao de retry deterministica, igual em todos os modos de conducao.
- *
- * Tres regras mandam aqui, e nenhuma delas e afrouxavel por modo:
- *
- *   1. **Custo nunca reexecuta.** `cost.violation` (despacho que seria redirecionado
- *      para provider pago) e o unico motivo sem retry automatico nenhum. Reexecutar
- *      violacao de custo e gastar de novo, e a licao dos US$ 16 esta no manifesto.
- *   2. **O modo afrouxa a PAUSA, nunca a VERIFICACAO.** A politica e identica em
- *      `#Look` e em `#Auto`. O que muda e a AUTORIZACAO: num bloco de loop que pausa,
- *      a acao espera `ork gate approve`; num bloco sem pausa (`#Maestro`, `#Auto`) o
- *      `ork` executa sozinho e grava a decisao autonoma no ledger.
- *   3. **O limite de escalacao pausa QUALQUER modo.** Estouradas as tentativas do
- *      manifesto pelo MESMO motivo na MESMA fase, a acao vira `escalar-humano`,
- *      inclusive em `#Auto`. E a invariante de escalacao tipada da secao 3.5.
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -61,6 +41,7 @@ exports.tabelaDaPolitica = tabelaDaPolitica;
 exports.ultimaReprovacao = ultimaReprovacao;
 exports.tentativasFeitas = tentativasFeitas;
 exports.blocoPausa = blocoPausa;
+exports.estadoTerminalDeRetry = estadoTerminalDeRetry;
 exports.planejarRetry = planejarRetry;
 exports.escalarEsforco = escalarEsforco;
 exports.redespachar = redespachar;
@@ -69,24 +50,58 @@ exports.retomarPedido = retomarPedido;
 exports.retomarFila = retomarFila;
 exports.retomarPorId = retomarPorId;
 exports.cancelarPedido = cancelarPedido;
+exports.alvosDeFallback = alvosDeFallback;
+exports.proximoAlvo = proximoAlvo;
+exports.producaoNoIntervalo = producaoNoIntervalo;
 exports.executarRetry = executarRetry;
 exports.textoDoPlano = textoDoPlano;
 exports.textoDoRetry = textoDoRetry;
 exports.textoDaRetomada = textoDaRetomada;
+const hitl_gates_1 = require("./hitl-gates");
+const claude_bg_1 = require("./adapters/claude-bg");
+/**
+ * Politica de retry TIPADA e retomada automatica (bloco B3).
+ *
+ * O B1 deu ao `ork` o MOTIVO tipado de cada reprovacao; o B2 deu a thread um estado
+ * retomavel em disco. O B3 e a camada que liga os dois: para cada motivo tipado existe
+ * UMA acao de retry deterministica, igual em todos os modos de conducao.
+ *
+ * Tres regras mandam aqui, e nenhuma delas e afrouxavel por modo:
+ *
+ *   1. **Custo nunca reexecuta.** `cost.violation` (despacho que seria redirecionado
+ *      para provider pago) e o unico motivo sem retry automatico nenhum. Reexecutar
+ *      violacao de custo e gastar de novo, e a politica `subscription-only` esta no manifesto.
+ *   2. **O modo afrouxa a PAUSA, nunca a VERIFICACAO.** A politica e identica em
+ *      `#Classic` e em `#Auto`. O que muda e a AUTORIZACAO: num bloco de loop que pausa,
+ *      a acao espera `ork gate approve`; num bloco sem pausa (`#Maestro`, `#Auto`) o
+ *      `ork` executa sozinho e grava a decisao autonoma no ledger.
+ *   3. **O limite de escalacao pausa QUALQUER modo.** Estouradas as tentativas do
+ *      manifesto pelo MESMO motivo na MESMA fase, a acao vira `escalar-humano`,
+ *      inclusive em `#Auto`. E a invariante de escalacao tipada da secao 3.5.
+ */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const adapter = __importStar(require("./adapters/claude-bg"));
 const fix_1 = require("./fix");
+const runtimes_1 = require("./runtimes");
+const setup_1 = require("./setup");
 const gates_1 = require("./gates");
 const ledger_1 = require("./ledger");
 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 runtime_profiles_1 = require("./runtime-profiles");
 const thread_1 = require("./thread");
 const tokens_1 = require("./tokens");
 const util_1 = require("./util");
 const worktree_1 = require("./worktree");
+const delegation_1 = require("./delegation");
+const gates_2 = require("./gates");
+const horario_1 = require("./horario");
+const conducao_1 = require("./conducao");
+const conducao_texto_1 = require("./conducao-texto");
 /**
  * Escada de esforco da 2a tentativa em diante.
  *
@@ -136,11 +151,22 @@ exports.POLITICA_DE_RETRY = {
         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',
     },
+    'runtime.autoconferencia': {
+        motivo: 'runtime.autoconferencia',
+        // `escalar-humano` e nao `sem-retry`: `sem-retry` e o lugar reservado a violacao
+        // de CUSTO, e o teste do bloco B3 guarda essa exclusividade de proposito. Aqui a
+        // maquina nao esta proibida de agir, ela esta sem o que escolher sozinha: quem
+        // 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',
+    },
     '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 (a licao dos US$ 16 e regra de codigo, nao lembrete)',
+        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',
     },
     'verify.regression': {
@@ -157,6 +183,27 @@ exports.POLITICA_DE_RETRY = {
         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',
     },
+    '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',
+    },
+    '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',
+    },
+    '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',
+    },
     'runtime.unavailable': {
         motivo: 'runtime.unavailable',
         acao: 'reexecutar',
@@ -164,6 +211,11 @@ exports.POLITICA_DE_RETRY = {
         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',
     },
+    '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',
+    },
     'runtime.rate-limited': {
         motivo: 'runtime.rate-limited',
         acao: 'esperar-janela',
@@ -171,6 +223,24 @@ exports.POLITICA_DE_RETRY = {
         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',
     },
+    // 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.
+    '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',
+    },
+    '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',
+    },
     'tree.blocked': {
         motivo: 'tree.blocked',
         acao: 'sincronizar-worktree',
@@ -185,6 +255,24 @@ exports.POLITICA_DE_RETRY = {
         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',
     },
+    // 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.
+    'conducao.em-andamento': {
+        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',
+    },
+    // 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.
+    'hitl.formato': {
+        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',
+    },
     'human.pending': {
         motivo: 'human.pending',
         acao: 'escalar-humano',
@@ -245,6 +333,9 @@ function tentativasFeitas(raiz, threadId, fase, motivo) {
 function blocoPausa(thread, fase) {
     return (0, thread_1.blocoDaThread)(thread, fase).pausa;
 }
+function estadoTerminalDeRetry(estado) {
+    return ['completed', 'failed', 'stopped', 'cancelled', 'interrupted', 'terminated'].includes(estado.trim().toLowerCase());
+}
 /**
  * Calcula o plano de retry SEM executar nada.
  *
@@ -327,10 +418,14 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
     const effort = escala ? escalarEsforco(effortBase, tentativas) : effortBase;
     const acao = escala ? 'escalar-esforco' : politica.acao;
     const pausa = blocoPausa(thread, fase);
-    const autorizado = (opcoes.autorizadoPor ?? '').trim() !== '';
+    const delegacao = (0, delegation_1.avaliarDelegacao)(manifesto, { thread: threadId, modo: thread.modo, fase,
+        escopo: 'premissas', conteudo: detalhe + '\n' + (0, delegation_1.conteudoDePremissas)(raiz, threadId) });
+    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}`;
     if (!politica.automatica) {
         automatica = false;
         bloqueio = 'politica.nao-automatica';
@@ -345,21 +440,18 @@ function planejarRetry(carregado, threadId, opcoes = {}) {
                 `(${(0, thread_1.blocoDaThread)(thread, fase).pausaSobre}): a acao ${acao} espera autorizacao humana. ` +
                 'O modo afrouxa a pausa, nunca a verificacao.';
     }
+    if (motivo === 'runtime.silencio') {
+        const despacho = ultimoDespachoFalho(raiz, threadId, fase, true);
+        const prova = opcoes.estadoDaSessao;
+        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';
+        }
+    }
     return {
-        thread: threadId,
-        modo: thread.modo,
-        fase,
-        motivo,
-        detalhe,
-        politica,
-        acao,
-        tentativas,
-        limite,
-        effort,
-        effortAnterior,
-        automatica,
-        bloqueio,
-        razao,
+        thread: threadId, modo: thread.modo, fase, motivo, detalhe, politica, acao, tentativas,
+        limite, effort, effortAnterior, automatica, bloqueio, razao,
     };
 }
 /** O esforco depois de `n` escaladas a partir do esforco base do manifesto. */
@@ -380,12 +472,19 @@ 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);
+}
+function redespacharSobLock(carregado, thread, fase, promptRelativo, sha, opcoes = {}) {
     const { raiz, manifesto } = carregado;
     const absoluto = path.isAbsolute(promptRelativo)
         ? promptRelativo
         : path.join(raiz, promptRelativo);
     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)) {
         return {
             ...vazio,
@@ -424,73 +523,171 @@ function redespachar(carregado, thread, fase, promptRelativo, sha, opcoes = {})
         });
         return { ...vazio, ok: false, motivo, detalhe, dryRun: opcoes.dryRun === true };
     }
-    const cwd = opcoes.cwd ?? thread.worktree ?? raiz;
-    // Mesma resolucao do `ork phase run`: a retomada carimba no ledger o par que ela de
-    // fato despachou, inclusive quando o pedido da fila trazia um modelo proprio.
-    const { model, effort } = (0, phase_1.resolverDespacho)(manifesto, {
-        model: opcoes.model ?? undefined,
-        effort: opcoes.effort ?? undefined,
-    });
-    const resultado = adapter.despachar({
-        prompt,
-        nome: slug,
-        cwd,
-        model,
-        effort,
-        dryRun: opcoes.dryRun,
-    });
-    if (opcoes.dryRun) {
+    // 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 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) {
+        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,
+                    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' });
+                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` };
+            }
+            const recusa = (0, conducao_1.recusaDeConducao)(thread.id, tomada.atual, pedidoDeConducao);
+            (0, conducao_1.registrarRecusa)(raiz, recusa);
+            return { ...vazio, ok: false, motivo: 'conducao.em-andamento', detalhe: recusa.texto, dryRun: false };
+        }
+        conducao = tomada;
+    }
+    try {
+        const cwd = opcoes.cwd ?? thread.worktree ?? raiz;
+        // 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
+        // que a fase original abriria.
+        const doBloco = (0, setup_1.configDoBloco)((0, setup_1.lerSetup)(raiz), thread.modo, fase);
+        const { runtime, model, effort } = (0, phase_1.resolverDespacho)(manifesto, {
+            runtime: opcoes.runtime ?? undefined,
+            model: opcoes.model ?? undefined,
+            effort: opcoes.effort ?? undefined,
+        }, doBloco);
+        const rt = (0, runtimes_1.resolverRuntime)(runtime);
+        // 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.
+        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;
+        }
+        // I-33 (D4, D7): a retomada escolhe o perfil como o `ork phase run`, com o login conferido.
+        let escolha;
+        try {
+            escolha = (0, phase_1.perfilParaDespacho)(carregado, thread, fase, runtime, { perfil: opcoes.perfil ?? undefined, dryRun: opcoes.dryRun,
+                origem: opcoes.origem ?? 'retry' });
+        }
+        catch (e) {
+            escolha = { perfil: null, configurados: 0, erro: e.message };
+        }
+        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,
+                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;
+        const resultado = rt.despachar({
+            prompt,
+            nome: slug,
+            cwd,
+            model,
+            effort,
+            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 },
+            ...(perfil ? { perfil } : {}),
+            ...(runtime === 'claude-bg' ? { contextoRuntime, ...(fase === 'PLAN' ? { 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),
+        });
+        if (opcoes.dryRun) {
+            return {
+                ok: true,
+                slug,
+                sessionId: null,
+                verificada: false,
+                motivo: null,
+                detalhe: 'ensaio (--dry-run): comando montado, nada despachado',
+                sinal: null,
+                comando: resultado.comando,
+                dryRun: true,
+            };
+        }
+        if (!resultado.ok || !resultado.sessionId) {
+            (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread.id), thread.id, 'phase_dispatch_failed', { fase, runtime, slug, cwd,
+                promptPath: absoluto, promptSha256: sha, controlador: resultado.controlador, model, effort,
+                erro: resultado.erro ?? 'runtime.unavailable: sem sessionId', origem: 'retry', ...(perfil ? { perfil } : {}) });
+            const sinal = resultado.rateLimit ?? null;
+            // I-33 (D5): a conta recusou o redespacho; o perfil sai do rodizio aqui, onde a evidencia esta.
+            if (resultado.falhaDeConta) {
+                try {
+                    (0, ratelimit_1.marcarContaDaFalha)(carregado, perfil, resultado.falhaDeConta);
+                }
+                catch { /* a rotacao segue pelo motivo tipado */ }
+            }
+            return {
+                ok: false,
+                slug,
+                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',
+                sinal,
+                falhaDeConta: resultado.falhaDeConta ?? null,
+                perfil: perfil ?? null,
+                comando: resultado.comando,
+                controlador: resultado.controlador,
+                dryRun: false,
+            };
+        }
+        const ctx = {
+            identidade,
+            canal,
+            ...(conducao ? { conducao } : {}),
+            prazoDaSessaoMs: pedidoDeConducao.prazoMs,
+            raiz,
+            thread,
+            fase,
+            slug,
+            promptPath: absoluto,
+            promptSha256: sha,
+            runtime,
+            cwd,
+            model,
+            effort,
+            origem: opcoes.origem ?? 'retry',
+            ...(perfil ? { perfil } : {}),
+            ...(headNoDespacho !== undefined ? { headNoDespacho } : {}),
+        };
+        (0, phase_1.concluirDespacho)(ctx, resultado.sessionId, resultado.verificada, resultado.comando, rt.fonteVerificacao, resultado.controlador);
         return {
             ok: true,
             slug,
-            sessionId: null,
-            verificada: false,
+            sessionId: resultado.sessionId,
+            verificada: resultado.verificada,
             motivo: null,
-            detalhe: 'ensaio (--dry-run): comando montado, nada despachado',
+            detalhe: `sessao ${resultado.sessionId} despachada com o mesmo prompt sha256 ${sha.slice(0, 12)}` +
+                (perfil ? ` no perfil ${perfil.id} (${runtime})` : ''),
             sinal: null,
-            comando: resultado.comando,
-            dryRun: true,
-        };
-    }
-    if (!resultado.ok || !resultado.sessionId) {
-        const sinal = resultado.rateLimit ?? null;
-        return {
-            ok: false,
-            slug,
-            sessionId: null,
-            verificada: false,
-            motivo: sinal ? 'runtime.rate-limited' : 'runtime.unavailable',
-            detalhe: resultado.erro ?? 'sem sessionId na saida do runtime',
-            sinal,
+            perfil: perfil ?? null,
             comando: resultado.comando,
             dryRun: false,
         };
     }
-    const ctx = {
-        raiz,
-        thread,
-        fase,
-        slug,
-        promptPath: absoluto,
-        promptSha256: sha,
-        runtime: manifesto.runtime.adapter,
-        cwd,
-        model,
-        effort,
-        origem: opcoes.origem ?? 'retry',
-    };
-    (0, phase_1.concluirDespacho)(ctx, resultado.sessionId, resultado.verificada, resultado.comando);
-    return {
-        ok: true,
-        slug,
-        sessionId: resultado.sessionId,
-        verificada: resultado.verificada,
-        motivo: null,
-        detalhe: `sessao ${resultado.sessionId} despachada com o mesmo prompt sha256 ${sha.slice(0, 12)}`,
-        sinal: null,
-        comando: resultado.comando,
-        dryRun: false,
-    };
+    finally {
+        // Retomada que nao virou sessao devolve a conducao; a que virou ja a entregou a sessao.
+        conducao?.liberar();
+    }
 }
 // ---------------------------------------------------------------------------
 // Os 3 playbooks de recuperacao, em codigo.
@@ -596,14 +793,25 @@ function retomarPedido(carregado, pedidoOriginal, opcoes = {}) {
     const slug = escolha.playbook === 'nova-sessao'
         ? (0, slug_1.proximaRotacao)(pedido.slug, [...thread.sessoes.map((s) => s.slug), pedido.slug])
         : pedido.slug;
-    const r = redespachar(carregado, thread, pedido.fase, pedido.promptPath, pedido.promptSha256, {
-        slug,
-        model: pedido.model,
-        effort: pedido.effort,
-        cwd: pedido.cwd,
-        origem: 'retry.rate-limit',
-        dryRun: opcoes.dryRun,
-    });
+    // I-33 (R3, D15/A4): pedido da conta retoma no primeiro runtime, original ou da ordem de fallback,
+    // cujo perfil da vez voltou: o prazo que liberou a fila pode ter sido o do fallback. Pedido antigo,
+    // sem os campos, segue igual.
+    const doPedido = pedido;
+    const alvo = alvoDaRetomada(carregado, thread, doPedido);
+    const r = !alvo.destino
+        ? { ok: false, slug, sessionId: null, verificada: false, motivo: doPedido.motivo ?? 'runtime.quota-exhausted',
+            detalhe: `${doPedido.motivo ?? 'runtime.quota-exhausted'}: nenhum perfil da vez disponivel em ${alvo.runtimes.join(', ')}`,
+            sinal: null, comando: [], dryRun: opcoes.dryRun === true }
+        : redespachar(carregado, thread, pedido.fase, pedido.promptPath, pedido.promptSha256, {
+            slug,
+            runtime: alvo.runtime,
+            perfil: alvo.perfil ?? doPedido.perfil ?? null,
+            model: alvo.model,
+            effort: alvo.effort,
+            cwd: pedido.cwd,
+            origem: 'retry.rate-limit',
+            dryRun: opcoes.dryRun,
+        });
     (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.retryTentado, {
         fase: pedido.fase,
         motivo: 'runtime.rate-limited',
@@ -638,6 +846,8 @@ function retomarPedido(carregado, pedidoOriginal, opcoes = {}) {
             playbook: escolha.playbook,
             slug,
             sessionId: r.sessionId,
+            ...(alvo.destino && alvo.runtime !== null ? { runtime: alvo.runtime } : {}),
+            ...(r.perfil ? { perfil: r.perfil.id } : {}),
             promptSha256: pedido.promptSha256,
             esperouAte: pedido.liberaEm,
             janelaEstimada: pedido.janelaEstimada,
@@ -666,12 +876,21 @@ function retomarPedido(carregado, pedidoOriginal, opcoes = {}) {
     }
     // Falhou de novo. Rate limit outra vez reagenda o MESMO pedido com a hora nova;
     // qualquer outro motivo devolve o pedido para a fila com a tentativa contada.
-    const novaJanela = r.sinal?.resetEm ?? pedido.liberaEm;
+    // D15 (A4): pedido da conta reagenda no proximo prazo entre TODOS os runtimes candidatos, e o
+    // novo prazo e sempre posterior ao instante da retomada: nada volta a vencer na mesma chamada.
+    const instante = Math.max(Date.parse(quando), Date.now());
+    const prazoDaConta = alvo.contas ? (0, runtime_profiles_1.prazoDaFila)((0, runtime_profiles_1.lerPerfisComContas)(raiz), alvo.runtimes, (0, runtime_profiles_1.politicaDeRotacao)(carregado.manifesto), instante) : null;
+    let novaJanela = prazoDaConta ?? r.sinal?.resetEm ?? pedido.liberaEm;
+    let estimada = prazoDaConta ? false : r.sinal ? r.sinal.resetEm === null : pedido.janelaEstimada;
+    if (alvo.contas && !(Date.parse(novaJanela) > instante)) {
+        novaJanela = new Date(instante + (0, ratelimit_1.janelaPadraoMs)(carregado.manifesto)).toISOString();
+        estimada = true;
+    }
     pedido = (0, ratelimit_1.gravarPedido)(raiz, {
         ...pedido,
         tentativas: pedido.tentativas + 1,
         liberaEm: novaJanela,
-        janelaEstimada: r.sinal ? r.sinal.resetEm === null : pedido.janelaEstimada,
+        janelaEstimada: estimada,
         sinal: r.sinal ?? pedido.sinal,
         detalhe: r.detalhe,
     });
@@ -687,6 +906,36 @@ function retomarPedido(carregado, pedidoOriginal, opcoes = {}) {
         dryRun: false,
     };
 }
+/**
+ * D15 (A4): o destino da retomada. Pedido da conta tenta o runtime original e depois cada runtime da
+ * ordem de fallback do bloco, e fica com o primeiro cujo perfil da vez esta disponivel agora, pela
+ * politica da D14. Runtime original sem perfil configurado segue pelo ambiente do processo, como
+ * antes; pedido antigo (rate limit) segue no runtime gravado.
+ */
+function alvoDaRetomada(carregado, thread, pedido) {
+    const { raiz, manifesto } = carregado;
+    const original = { runtime: pedido.runtime ?? null, model: pedido.model, effort: pedido.effort };
+    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 }))];
+    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) {
+        if ((0, runtime_profiles_1.perfisDoRuntime)(store, c.runtime).length === 0) {
+            if (c.runtime === principal)
+                return { ...c, destino: true, perfil: null, runtimes, contas: true };
+            continue;
+        }
+        const p = (0, runtime_profiles_1.proximoPerfilDisponivel)(store, c.runtime, politica);
+        if (p)
+            return { ...c, destino: true, perfil: p.id, runtimes, contas: true };
+    }
+    return { destino: false, runtime: null, model: pedido.model, effort: pedido.effort, runtimes, contas: true };
+}
 /** Retoma todos os pedidos cuja janela ja liberou. */
 function retomarFila(carregado, opcoes = {}) {
     const quando = opcoes.quando ?? (0, util_1.agora)();
@@ -715,12 +964,123 @@ function cancelarPedido(carregado, id, motivo) {
     });
     return cancelado;
 }
+/**
+ * D6 (A13): a ordem de fallback do bloco, `runtime:modelo[:esforco]`, pelo parser unico do setup
+ * (domicilio da D6): entrada malformada, runtime nao homologado, repetido ou igual ao principal e
+ * descartada com as mesmas regras da edicao e da listagem.
+ */
+function alvosDeFallback(bloco, principal) {
+    return (0, setup_1.alvosDaOrdemDeFallback)(bloco?.fallback, principal);
+}
+/**
+ * D5, D14, D16: proximo destino do MESMO prompt. Primeiro o perfil da vez do mesmo runtime (outro
+ * perfil so com a troca do manifesto ligada para o motivo: por cota, ligada por padrao desde a
+ * decisao do dono em 19/09/2026); depois cada runtime da ordem de fallback (perfil da vez dele, ou o ambiente do
+ * processo quando ele nao tem perfil configurado e esse ambiente ainda nao falhou nesta rotacao).
+ * Sem destino, `null`.
+ */
+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 });
+    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)
+            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 });
+            if (p)
+                return { runtime: f.runtime, perfil: (0, runtime_profiles_1.perfilDeDespacho)(p), model: f.model, effort: f.effort ?? null };
+            continue;
+        }
+        if (!excluir.runtimesImplicitos.includes(f.runtime))
+            return { runtime: f.runtime, perfil: null, model: f.model, effort: f.effort ?? null };
+    }
+    return null;
+}
+/**
+ * D11 (c): o intervalo do despacho produziu alguma coisa? Leitura de disco, do ledger e do git,
+ * como a prova da I-34: artefato da fase gravado, commit registrado, entrega registrada ou, no
+ * GO, HEAD movido ou worktree alterada. Duvida conta como producao (fail-closed): so o intervalo
+ * provadamente vazio aceita redespacho do mesmo prompt.
+ */
+function producaoNoIntervalo(raiz, thread, sessao, eventos) {
+    const fonte = (0, session_watcher_claude_1.fonteRegistrada)(eventos, sessao);
+    const saida = (0, session_watcher_claude_1.saidaDoArtefato)(raiz, thread.id, sessao, fonte, eventos);
+    if (saida?.produzido)
+        return { produziu: true, evidencia: `${saida.arquivo} gravado no intervalo do despacho` };
+    const intervalo = (0, session_watcher_claude_1.eventosDoIntervalo)(eventos, sessao);
+    const commits = intervalo.filter(e => e.tipo === 'mcp_git_committed' || (e.tipo === 'commit' && e.sessionId === sessao.sessionId));
+    if (commits.length)
+        return { produziu: true, evidencia: `${commits.length} commit(s) registrado(s) no intervalo do despacho` };
+    const entrega = intervalo.find(e => e.tipo === 'ship_done' || e.tipo === 'score_proposto');
+    if (entrega)
+        return { produziu: true, evidencia: `${entrega.tipo} registrado no intervalo do despacho` };
+    if (sessao.fase === 'GO') {
+        const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessao.sessionId).at(-1);
+        // I-33 (N1): o HEAD vem do registro do despacho em qualquer runtime (claude-bg e codex); commit feito
+        // 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 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' };
+        if ((0, session_watcher_claude_1.headDaWorktree)(cwd) !== head)
+            return { produziu: true, evidencia: 'HEAD da worktree mudou desde o despacho' };
+        const status = (0, util_1.exec)('git', ['status', '--porcelain', '--', '.', ':(exclude).orkastery'], cwd, 30000);
+        if (!status.ok)
+            return { produziu: true, evidencia: 'git status da worktree falhou; producao nao descartada' };
+        if (status.stdout.trim() !== '')
+            return { produziu: true, evidencia: 'worktree com alteracoes nao commitadas' };
+    }
+    return { produziu: false, evidencia: 'nenhum artefato, commit, entrega ou alteracao da worktree no intervalo do despacho' };
+}
+/** O despacho que falhou pela conta: o da sessao do gate (observador) ou o ultimo recusado na fase. */
+function despachoDaFalha(eventos, gate, fase) {
+    if (gate && typeof gate.sessionId === 'string')
+        return eventos.filter(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada && e.sessionId === gate.sessionId).at(-1) ?? null;
+    for (let i = eventos.length - 1; i >= 0; i--) {
+        const e = eventos[i];
+        if (e.fase === fase && e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou)
+            return e;
+        if (e.fase === fase && e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada)
+            return null;
+    }
+    return null;
+}
+function perfilDoEvento(e) {
+    return e && e.perfil !== undefined && e.perfil !== null ? (0, runtime_profiles_1.validarPerfilDeDespacho)(e.perfil) : 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;
+    try {
+        atual = (0, runtime_profiles_1.lerPerfis)(raiz).perfis.find(p => p.id === perfil.id);
+    }
+    catch {
+        return false;
+    }
+    if (!atual)
+        return false;
+    return falha.motivo === 'runtime.quota-exhausted'
+        ? atual.estado === 'esgotado' && atual.esgotadoAte !== null && Date.parse(atual.esgotadoAte) > agoraMs
+        : atual.estado === 'sem-auth';
+}
+function sinalDoGate(gate, motivo) {
+    const f = gate?.falhaDeConta;
+    return { motivo: motivo === 'runtime.auth-missing' ? 'runtime.auth-missing' : 'runtime.quota-exhausted',
+        resetEm: typeof f?.resetEm === 'string' ? f.resetEm : null, fonte: f?.fonte ?? 'sem-horario',
+        trecho: typeof f?.trecho === 'string' ? f.trecho : String(gate?.detalhe ?? motivo).slice(0, 200) };
+}
 /** O ultimo despacho que falhou nesta fase, de onde sai o prompt a redespachar. */
-function ultimoDespachoFalho(raiz, threadId, fase) {
+function ultimoDespachoFalho(raiz, threadId, fase, silencio = false) {
     const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId));
     for (let i = eventos.length - 1; i >= 0; i--) {
         const e = eventos[i];
-        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou && e.fase === fase)
+        if (e.fase === fase && (e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou ||
+            (silencio && e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada)))
             return e;
     }
     return null;
@@ -733,7 +1093,18 @@ function ultimoDespachoFalho(raiz, threadId, fase) {
  */
 function executarRetry(carregado, threadId, opcoes = {}) {
     const { raiz } = carregado;
-    const plano = planejarRetry(carregado, threadId, opcoes);
+    let plano = planejarRetry(carregado, threadId, { ...opcoes, estadoDaSessao: undefined });
+    if (plano.motivo === 'runtime.silencio' && plano.fase && plano.tentativas < plano.limite) {
+        const despacho = ultimoDespachoFalho(raiz, threadId, plano.fase, true);
+        // O adapter Codex da baseline nao fornece prova terminal. I-04 adiciona esse contrato.
+        if (despacho?.runtime === 'claude-bg' && typeof despacho.sessionId === 'string') {
+            const consulta = (0, claude_bg_1.consultarSessoes)(undefined, true);
+            const sessao = consulta.ok ? consulta.sessoes.find(s => s.sessionId === despacho.sessionId) : undefined;
+            const estado = sessao?.state ?? sessao?.status;
+            plano = planejarRetry(carregado, threadId, { ...opcoes,
+                estadoDaSessao: typeof estado === 'string' ? { sessionId: despacho.sessionId, estado } : undefined });
+        }
+    }
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     const vazio = {
@@ -798,12 +1169,23 @@ function executarRetry(carregado, threadId, opcoes = {}) {
             effortAnterior: plano.effortAnterior,
             dryRun: opcoes.dryRun === true,
             autorizadoPor: blocoPausa(thread, plano.fase)
-                ? (opcoes.autorizadoPor ?? 'humano')
+                ? ((0, gates_2.aprovacoesHumanas)(raiz, threadId).some(e => e.fase === plano.fase && e.autorizadoPor === opcoes.autorizadoPor)
+                    ? opcoes.autorizadoPor : `delegacao:${carregado.manifesto.conduction.delegation?.delegado ?? 'ausente'}`)
                 : `politica de retry do bloco B3 (bloco sem pausa no modo ${thread.modo})`,
             ok,
             detalhe,
         });
     };
+    // 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';
+        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');
@@ -833,8 +1215,11 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         registrarTentativa(rodada.correcoes.length > 0, detalhe);
         return { ...vazio, executada: rodada.correcoes.length > 0, rodada, reverify, detalhe };
     }
+    if (plano.motivo === 'runtime.quota-exhausted' || plano.motivo === 'runtime.auth-missing') {
+        return rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTentativa);
+    }
     // `reexecutar` e `escalar-esforco`: o MESMO prompt volta ao runtime.
-    const falho = ultimoDespachoFalho(raiz, threadId, plano.fase);
+    const falho = ultimoDespachoFalho(raiz, threadId, plano.fase, 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 "..."\``;
@@ -843,6 +1228,7 @@ 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,
         model: typeof falho.model === 'string' ? falho.model : null,
         origem: 'retry.run',
         dryRun: opcoes.dryRun,
@@ -855,6 +1241,134 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         detalhe: redespacho.detalhe,
     };
 }
+/**
+ * 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.
+ */
+function rotacionarConta(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 = plano.motivo;
+    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 approve ${thread.id} retomada --por <quem>`, fase, origem: 'retry.rotacao', pausaQualquerModo: true });
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.retryEscalado, { fase, motivo, origem: 'retry.rotacao', 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;
+    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', `rotacao recusada: ${e.message}`);
+    }
+    // D11 (c): sessao que morreu por cota depois de produzir nao e redespachada.
+    if (typeof gate?.sessionId === 'string' && typeof gate.despachoEm === 'string') {
+        const producao = producaoNoIntervalo(raiz, thread, { sessionId: gate.sessionId, fase, despachadaEm: gate.despachoEm }, eventos);
+        if (producao.produziu) {
+            return escalar('producao parcial sob falha da conta', `producao parcial sob ${motivo === 'runtime.quota-exhausted' ? 'cota esgotada' : 'auth ausente'}: ${producao.evidencia}; ` +
+                'a sessao nao e redespachada sobre a worktree alterada e a fase nao conclui sem o humano');
+        }
+    }
+    const doBloco = (0, setup_1.configDoBloco)((0, setup_1.lerSetup)(raiz), thread.modo, fase);
+    const fallback = alvosDeFallback(doBloco, doBloco?.runtime ?? manifesto.runtime.adapter);
+    const politica = (0, runtime_profiles_1.politicaDeRotacao)(manifesto);
+    const falha = sinalDoGate(gate, motivo);
+    // I-33 (D12): o observador ja marca o perfil no caminho terminal; remarcar empurraria o prazo a cada retry.
+    if (!opcoes.dryRun && perfil && !jaMarcado(raiz, perfil, falha)) {
+        try {
+            (0, ratelimit_1.marcarContaDaFalha)(carregado, perfil, falha);
+        }
+        catch { /* o store pode ja estar marcado */ }
+    }
+    const tentados = [];
+    const implicitos = perfil ? [] : [runtime];
+    let atual = { runtime, perfil };
+    let tentativas = plano.tentativas;
+    let ultimo = null;
+    let falhaAtual = falha;
+    const emitir = (para, razao) => {
+        if (!opcoes.dryRun)
+            (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,
+                autorizadoPor: `politica de retry da I-33 (D5), bloco sem pausa ou delegado no modo ${thread.modo}` });
+    };
+    for (;;) {
+        const alvo = proximoAlvo(raiz, atual, fallback, { perfis: tentados, runtimesImplicitos: implicitos }, politica);
+        if (!alvo)
+            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, {
+            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,
+        });
+        registrarTentativa(ultimo.ok, ultimo.detalhe);
+        tentativas += 1;
+        if (ultimo.ok || opcoes.dryRun)
+            return { ...vazio, executada: ultimo.ok, redespacho: ultimo, detalhe: ultimo.detalhe };
+        // So a recusa da CONTA no redespacho (nada rodou) continua a rotacao; outra falha para aqui.
+        if (!ultimo.falhaDeConta && ultimo.motivo !== 'runtime.auth-missing' && ultimo.motivo !== 'runtime.quota-exhausted')
+            return { ...vazio, redespacho: ultimo, detalhe: ultimo.detalhe };
+        if (alvo.perfil)
+            tentados.push(alvo.perfil.id);
+        else
+            implicitos.push(alvo.runtime);
+        atual = { runtime: alvo.runtime, perfil: alvo.perfil };
+        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`);
+        }
+    }
+    // Sem destino: a fila so faz sentido quando algum perfil tem prazo para voltar. Sem perfil (ambiente do
+    // processo), o prazo e o horario dito pelo proprio runtime, quando ainda esta no futuro.
+    const runtimes = [runtime, ...fallback.map(f => f.runtime)];
+    const dito = !perfil && falhaAtual.resetEm !== null && Date.parse(falhaAtual.resetEm) > Date.now() ? falhaAtual.resetEm : null;
+    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');
+    }
+    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,
+        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 });
+    (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,
+        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}` };
+}
 /** Texto de `ork retry plan`. */
 function textoDoPlano(p) {
     const linhas = [];
@@ -863,7 +1377,7 @@ function textoDoPlano(p) {
     linhas.push(`  fase            ${p.fase ?? '(nenhuma)'}`);
     linhas.push(`  motivo tipado   ${p.motivo ?? '(nenhuma reprovacao pendente)'}`);
     if (p.detalhe)
-        linhas.push(`  detalhe         ${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})` : ''}`);
@@ -873,13 +1387,16 @@ function textoDoPlano(p) {
     linhas.push(`  razao           ${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((0, horario_1.legendaDoFuso)());
     return linhas.join('\n');
 }
 /** Texto de `ork retry run`. */
 function textoDoRetry(r) {
-    const linhas = [textoDoPlano(r.plano), ''];
+    const plano = textoDoPlano(r.plano);
+    const linhas = [plano, ''];
     linhas.push(`Execucao: ${r.executada ? 'acao executada' : 'nada executado'}`);
-    linhas.push(`  ${r.detalhe}`);
+    linhas.push(`  ${(0, horario_1.localizarTexto)(r.detalhe)}`);
     if (r.rodada && r.rodada.correcoes.length > 0) {
         linhas.push('');
         linhas.push(`GO-FIX rodada ${r.rodada.rodada}: ` +
@@ -892,9 +1409,12 @@ function textoDoRetry(r) {
         linhas.push('');
         linhas.push('Fila de rate limit desta thread:');
         for (const p of r.fila) {
-            linhas.push(`  ${p.id}  ${p.fase}  libera em ${p.liberaEm}${p.janelaEstimada ? ' (janela estimada)' : ''}`);
+            linhas.push(`  ${p.id}  ${p.fase}  libera em ${(0, horario_1.formatarDataHora)(p.liberaEm)}${p.janelaEstimada ? ' (janela estimada)' : ''}`);
         }
     }
+    if ((r.fila.length > 0 || (0, horario_1.localizarTexto)(r.detalhe) !== r.detalhe) && !plano.includes((0, horario_1.legendaDoFuso)())) {
+        linhas.push((0, horario_1.legendaDoFuso)());
+    }
     return linhas.join('\n');
 }
 /** Texto de `ork retry resume`. */
@@ -910,8 +1430,10 @@ function textoDaRetomada(rs) {
         linhas.push(`  retomada    ${r.despachada ? `sim (sessao ${r.sessionId})` : 'nao'}`);
         if (r.motivo)
             linhas.push(`  motivo      ${r.motivo}`);
-        linhas.push(`  detalhe     ${r.detalhe}`);
+        linhas.push(`  detalhe     ${(0, horario_1.localizarTexto)(r.detalhe)}`);
         linhas.push(`  estado      ${r.pedido.estado}`);
     }
+    if (rs.some((r) => (0, horario_1.localizarTexto)(r.detalhe) !== r.detalhe))
+        linhas.push((0, horario_1.legendaDoFuso)());
     return linhas.join('\n');
 }