@orkastery/cli 0.2.0 → 0.4.1

package/dist/phase.js

@@ -1,12 +1,4 @@
 "use strict";
-/**
- * `ork phase run|list`: despacho de fase pelo runtime adapter e leitura do ledger.
- *
- * O prompt e montado pelo `ork` (nomenclatura das fases + modo de conducao + contexto da
- * thread + pedido do builder), gravado com hash sha256 no diretorio da thread e so entao
- * despachado. Depois do despacho o `ork` RE-VERIFICA no runtime que a sessao existe:
- * self-report de despacho nao vale como evidencia.
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -42,6 +34,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REGRAS_DE_EVIDENCIA = exports.CONTRATO_DAS_FASES = void 0;
+exports.escolherPerfil = escolherPerfil;
+exports.perfilParaDespacho = perfilParaDespacho;
+exports.runtimeCruzadoParaDespacho = runtimeCruzadoParaDespacho;
+exports.estadoParaDespacho = estadoParaDespacho;
+exports.fasesDoCicloNoPrompt = fasesDoCicloNoPrompt;
 exports.valoresDoPrompt = valoresDoPrompt;
 exports.montarPrompt = montarPrompt;
 exports.montarPromptComMemoria = montarPromptComMemoria;
@@ -50,16 +47,33 @@ exports.slugDaSessao = slugDaSessao;
 exports.resolverDespacho = resolverDespacho;
 exports.dadosDoDespacho = dadosDoDespacho;
 exports.concluirDespacho = concluirDespacho;
+exports.prazoDaSessao = prazoDaSessao;
 exports.rodarFase = rodarFase;
 exports.tabelaDoLedger = tabelaDoLedger;
 exports.descreverSlug = descreverSlug;
+const hitl_gates_1 = require("./hitl-gates");
+const runtime_context_1 = require("./runtime-context");
+/**
+ * `ork phase run|list`: despacho de fase pelo runtime adapter e leitura do ledger.
+ *
+ * O prompt e montado pelo `ork` (nomenclatura das fases + modo de conducao + contexto da
+ * thread + pedido do builder), gravado com hash sha256 no diretorio da thread e so entao
+ * despachado. Depois do despacho o `ork` RE-VERIFICA no runtime que a sessao existe:
+ * self-report de despacho nao vale como evidencia.
+ */
 const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const adapter = __importStar(require("./adapters/claude-bg"));
+const session_watcher_1 = require("./session-watcher");
+const session_watcher_claude_1 = require("./session-watcher-claude");
+const runtimes_1 = require("./runtimes");
+const setup_1 = require("./setup");
 const modos_1 = require("./modos");
 const gates_1 = require("./gates");
 const policies_1 = require("./policies");
 const ratelimit_1 = require("./ratelimit");
+const claude_bg_1 = require("./adapters/claude-bg");
+const codex_1 = require("./adapters/codex");
 const memoria_1 = require("./memoria");
 const prompts_1 = require("./prompts");
 const slug_1 = require("./slug");
@@ -67,6 +81,145 @@ const thread_1 = require("./thread");
 const types_1 = require("./types");
 const util_1 = require("./util");
 const ledger_1 = require("./ledger");
+const estado_thread_1 = require("./estado-thread");
+const horario_1 = require("./horario");
+const runtime_profiles_1 = require("./runtime-profiles");
+const maquina_1 = require("./maquina");
+const fabrica_publicar_1 = require("./fabrica-publicar");
+const conducao_1 = require("./conducao");
+/**
+ * I-33 (D2, D4, D14): o perfil do despacho. Sem perfis do runtime no store, nenhum (P8). Com
+ * perfis, o pedido explicito ou o perfil da vez na ordem do store pela politica de rotacao do
+ * manifesto (sem ela, a padrao da D16); perfil esgotado, sem auth, pago ou desativado nunca
+ * recebe despacho.
+ */
+function escolherPerfil(raiz, runtime, opcoes = {}) {
+    // I-49: o despacho enxerga o estado que as outras fabricas viram na mesma conta.
+    const store = (0, runtime_profiles_1.lerPerfisComContas)(raiz, opcoes.agoraMs);
+    const doRuntime = (0, runtime_profiles_1.perfisDoRuntime)(store, runtime);
+    if (opcoes.perfil !== undefined) {
+        const pedido = doRuntime.find(p => p.id === opcoes.perfil);
+        if (!pedido)
+            return { perfil: null, configurados: doRuntime.length, erro: `perfil "${opcoes.perfil}" nao existe para o runtime ${runtime}` };
+        if (!(0, runtime_profiles_1.perfilDisponivel)(pedido, opcoes.agoraMs))
+            return { perfil: null, configurados: doRuntime.length,
+                erro: `perfil "${pedido.id}" esta ${pedido.estado}${pedido.esgotadoAte ? ` ate ${pedido.esgotadoAte}` : ''}` };
+        return { perfil: (0, runtime_profiles_1.perfilDeDespacho)(pedido), configurados: doRuntime.length };
+    }
+    if (doRuntime.length === 0)
+        return { perfil: null, configurados: 0 };
+    const proximo = (0, runtime_profiles_1.proximoPerfilDisponivel)(store, runtime, opcoes.politica ?? runtime_profiles_1.POLITICA_PADRAO, opcoes);
+    if (proximo)
+        return { perfil: (0, runtime_profiles_1.perfilDeDespacho)(proximo), configurados: doRuntime.length };
+    const agoraMs = opcoes.agoraMs ?? Date.now();
+    // Motivo do bloqueio pelo estado dos perfis: com algum esgotado ha prazo (fila); so sem-auth, login;
+    // so provider pago (D13), custo: `cost.violation` nunca recebe retry automatico.
+    const motivo = doRuntime.some(p => p.estado === 'esgotado' && p.esgotadoAte !== null && Date.parse(p.esgotadoAte) > agoraMs)
+        ? 'runtime.quota-exhausted' : doRuntime.some(p => p.estado === 'sem-auth') ? 'runtime.auth-missing'
+        : doRuntime.some(p => p.estado === 'provider-pago') ? 'cost.violation' : 'runtime.unavailable';
+    return { perfil: null, configurados: doRuntime.length, motivo,
+        erro: `nenhum perfil disponivel do runtime ${runtime} (${doRuntime.map(p => `${p.id}: ${p.estado}`).join(', ')})` };
+}
+/**
+ * I-33 (D7, D13): preflight de auth antes do despacho. O perfil escolhido tem o login conferido
+ * pelo proprio CLI com o env dele; reprovado, vira `sem-auth` no store (ou `provider-pago`, quando
+ * o login e por API key, helper, Console ou nuvem), a troca vai ao ledger (`runtime_profile_rotated`)
+ * e o proximo perfil do mesmo runtime e conferido. Perfil sem login de assinatura nunca recebe
+ * despacho. Sem perfil (ambiente do processo) ou em ensaio, nada e conferido.
+ */
+function perfilParaDespacho(carregado, thread, fase, runtime, opcoes) {
+    const { raiz } = carregado;
+    const excluir = [...(opcoes.excluir ?? [])];
+    const politica = (0, runtime_profiles_1.politicaDeRotacao)(carregado.manifesto);
+    for (;;) {
+        const escolha = escolherPerfil(raiz, runtime, { perfil: opcoes.perfil, excluir, politica });
+        if (escolha.erro || !escolha.perfil || opcoes.dryRun)
+            return escolha;
+        const auth = runtime === 'claude-bg' ? (0, claude_bg_1.conferirAuth)(escolha.perfil) : runtime === 'codex' ? (0, codex_1.conferirAuth)(escolha.perfil)
+            : { ok: false, detalhe: `runtime ${runtime} sem conferencia de login` };
+        if (auth.ok)
+            return escolha;
+        let motivo, razao;
+        if (auth.transitorio) {
+            // A14: conferencia inconclusiva nao marca sem-auth: o perfil fica fora so deste despacho.
+            (0, runtime_profiles_1.registrarConferenciaInconclusiva)(raiz, escolha.perfil.id, auth.detalhe);
+            motivo = 'runtime.unavailable';
+            razao = 'a conferencia de login nao concluiu (A14): o perfil fica fora so deste despacho e e conferido de novo no proximo';
+        }
+        else if (auth.pago) {
+            // D13: login valido, mas cobrado por token. O perfil sai do rodizio com estado proprio e nunca despacha.
+            (0, runtime_profiles_1.marcarFalhaDePerfil)(raiz, escolha.perfil.id, { estado: 'provider-pago', esgotadoAte: null, motivo: 'cost.violation', detalhe: auth.detalhe });
+            motivo = 'cost.violation';
+            razao = 'o preflight achou login por provider pago (D13): perfil de API key, helper, Console ou nuvem nunca recebe despacho';
+        }
+        else {
+            const falha = { motivo: 'runtime.auth-missing', resetEm: null, fonte: 'sem-horario', trecho: auth.detalhe };
+            (0, ratelimit_1.marcarContaDaFalha)(carregado, escolha.perfil, falha);
+            motivo = falha.motivo;
+            razao = 'o preflight de auth reprovou o perfil antes do despacho (D7): perfil sem login nunca recebe despacho';
+        }
+        excluir.push(escolha.perfil.id);
+        const proximo = opcoes.perfil === undefined ? escolherPerfil(raiz, runtime, { excluir, politica }).perfil : null;
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread.id), thread.id, ledger_1.TIPOS_DE_EVENTO.perfilRotacionado, {
+            fase, motivo, origem: `${opcoes.origem}.preflight`,
+            de: { runtime, perfil: escolha.perfil.id }, para: proximo ? { runtime, perfil: proximo.id } : null,
+            evidencia: auth.detalhe, razao,
+            autorizadoPor: 'politica de rotacao da I-33 (D5, D7, D13), igual em todos os modos',
+        });
+        if (opcoes.perfil !== undefined)
+            return { perfil: null, configurados: escolha.configurados, motivo,
+                erro: `perfil "${opcoes.perfil}" ${auth.transitorio ? 'com conferencia de login inconclusiva' : auth.pago ? 'autenticado por provider pago' : 'sem login conferido'}: ${auth.detalhe}` };
+    }
+}
+/**
+ * O CHECK desta thread pode rodar neste runtime? (I-43, D4, viga a)
+ *
+ * A regra: quem VALIDA nao pode ser quem EXECUTOU. Ela vinha do Objective Envelope,
+ * onde valia so na criacao e para tres threads que nunca rodaram nada; aqui ela passa
+ * a valer no despacho de qualquer thread que a exija.
+ *
+ * Compara o runtime do CHECK com os runtimes das sessoes de GO JA REGISTRADAS em
+ * `thread.sessoes`, que ja carregam `runtime` e ja aparecem em `ork thread status`.
+ * Nenhum dado novo precisa ser coletado: o que faltava era a regra, nao o dado.
+ *
+ * Sem sessao de GO registrada nao ha o que cruzar, e o despacho passa: inventar
+ * impedimento sobre um GO que nao aconteceu seria barrar por suposicao.
+ */
+function runtimeCruzadoParaDespacho(thread, fase, runtime) {
+    if (thread.exigeRuntimeDiferente !== true || fase !== 'CHECK')
+        return null;
+    const doGo = [...new Set(thread.sessoes.filter((s) => s.fase === 'GO').map((s) => s.runtime))];
+    if (doGo.length === 0)
+        return null;
+    if (!doGo.includes(runtime))
+        return null;
+    return `runtime.autoconferencia: o CHECK precisa de runtime diferente do GO, e "${runtime}" `
+        + `foi o runtime do GO desta thread (${doGo.join(', ')}). `
+        + `Despache o CHECK em outro runtime, ou tire a exigencia da thread.`;
+}
+/**
+ * I-43 (T11): o ramo do Objective Envelope saiu daqui.
+ *
+ * Ele era a UNICA consulta do produto ao envelope, e dependia de `thread.creationOrigin`.
+ * A medida: das 137 threads do projeto, ZERO tinham `creationOrigin`. O ramo nunca
+ * disparou para thread nenhuma, e a "unica pausa planejada do #Maestro" nao bloqueava
+ * o despacho nem das tres threads que o proprio envelope criou.
+ *
+ * O que ele PRETENDIA garantir (que ninguem despacha sem validacao combinada) continua
+ * garantido, e agora de verdade, por `runtimeCruzadoParaDespacho` logo acima e pelos
+ * criterios de pronto executaveis que `ork verify` cobra.
+ */
+function estadoParaDespacho(raiz, thread, dryRun = false) {
+    if (!thread.worktree)
+        return null;
+    try {
+        (0, estado_thread_1.vincularEstado)(raiz, thread.id, thread.worktree, dryRun);
+        return null;
+    }
+    catch (e) {
+        return e.message;
+    }
+}
 /** O que cada fase canonica entrega. Vai no cabecalho do prompt de toda sessao. */
 exports.CONTRATO_DAS_FASES = {
     GOAL: 'GOAL (F1): objetivo verificavel, impact map, criterios de sucesso e claims com comando de verificacao. Nao implementa.',
@@ -82,6 +235,21 @@ exports.REGRAS_DE_EVIDENCIA = [
     'Trabalhe apenas no diretorio de trabalho indicado acima.',
     'Passos irreversiveis (push, merge, delecao) so acontecem quando o modo autoriza.',
 ];
+/**
+ * I-42 (D11): as fases que o cabecalho do prompt descreve.
+ *
+ * Regra por desenho de bloco, nunca por nome de modo: quando o ciclo e um bloco so e esse bloco
+ * nao percorre as seis fases, o prompt descreve so as fases dele. As outras cinco linhas seriam
+ * cerimonia de um ciclo que a sessao nao vai percorrer. Bloco unico com as seis fases e ciclo de
+ * varios blocos continuam com as seis linhas, byte a byte.
+ */
+function fasesDoCicloNoPrompt(thread) {
+    const [unico, ...resto] = thread.blocos;
+    if (unico && resto.length === 0 && unico.fases.length < types_1.FASES.length) {
+        return types_1.FASES.filter((f) => unico.fases.includes(f));
+    }
+    return types_1.FASES;
+}
 /**
  * Os valores que o template de fase recebe.
  *
@@ -98,7 +266,7 @@ function valoresDoPrompt(thread, fase, pedido, memoriaInjetada = '') {
         thread: thread.id,
         bloco: bloco.fases.join('-'),
         nome: thread.nome,
-        ciclo_canonico: types_1.FASES.map((f) => `${bloco.fases.includes(f) ? '>' : ' '} ${exports.CONTRATO_DAS_FASES[f]}`).join('\n'),
+        ciclo_canonico: fasesDoCicloNoPrompt(thread).map((f) => `${bloco.fases.includes(f) ? '>' : ' '} ${exports.CONTRATO_DAS_FASES[f]}`).join('\n'),
         tag: def.tag,
         blocos: thread.blocos.map((b) => b.fases.join('-')).join(' / '),
         pausas: String(thread.blocos.filter((b) => b.pausa).length),
@@ -150,6 +318,16 @@ function montarPromptComMemoria(carregado, thread, fase, pedido, memoria) {
 function hashDoPrompt(prompt) {
     return (0, node_crypto_1.createHash)('sha256').update(prompt, 'utf8').digest('hex');
 }
+function schemaDeClaimsDoPacote() {
+    const candidatos = [
+        path.join(__dirname, '..', 'schemas', 'claims.schema.json'),
+        path.join(__dirname, '..', '..', 'schemas', 'claims.schema.json'),
+    ];
+    const arquivo = candidatos.find(c => fs.existsSync(c));
+    if (!arquivo)
+        throw new Error('runtime.unavailable: schema de claims nao encontrado no pacote');
+    return JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+}
 /** Slug da sessao que conduz esta fase, rotacionando quando o slug ja foi usado na thread. */
 function slugDaSessao(thread, fase) {
     const bloco = (0, thread_1.blocoDaThread)(thread, fase);
@@ -160,18 +338,28 @@ function slugDaSessao(thread, fase) {
     return (0, slug_1.proximaRotacao)(base, usados);
 }
 /**
- * Modelo e esforco EFETIVAMENTE usados num despacho, resolvidos numa funcao so.
+ * Runtime, modelo e esforco EFETIVAMENTE usados num despacho, resolvidos numa funcao so.
+ *
+ * Precedencia (decisao D4 da thread ork-homologarcod): opcao explicita do CLI > setup do
+ * bloco (feature #setup, `.orkastery/setup.json`) > runtime do manifesto.
  *
  * Regra do esforco: quem informa SO o modelo esta pedindo o despacho mais capaz que
- * existe, entao o esforco assume `high` em vez de herdar o do manifesto. Quem informa o
- * esforco manda, e sem nenhum dos dois vale o manifesto. Resolver isso aqui, e nao no
- * ponto de chamada, e o que permite gravar o par no ledger como FATO: o mesmo valor que
- * foi para o runtime adapter e o que fica carimbado no evento.
+ * existe, entao o esforco assume `high` em vez de herdar o do setup ou do manifesto.
+ * Quem informa o esforco manda. Resolver isso aqui, e nao no ponto de chamada, e o que
+ * permite gravar o trio no ledger como FATO: o mesmo valor que foi para o runtime
+ * adapter e o que fica carimbado no evento.
  */
-function resolverDespacho(manifesto, opcoes) {
-    const model = opcoes.model ?? manifesto.runtime.model;
-    const effort = opcoes.effort ?? (opcoes.model !== undefined ? 'high' : manifesto.runtime.effort);
-    return { model, effort };
+function resolverDespacho(manifesto, opcoes, doBloco) {
+    const origem = doBloco?.runtime ?? manifesto.runtime.adapter;
+    const runtime = opcoes.runtime ?? origem;
+    if ((0, runtimes_1.runtimeConhecido)(runtime) && runtime !== origem && !opcoes.model?.trim())
+        throw new Error(`setup.model.required: ao trocar runtime de ${origem} para ${runtime}, informe --runtime ${runtime} --model <modelo> para este despacho; o setup do projeto permanece intacto.`);
+    const model = opcoes.model ?? doBloco?.model ?? manifesto.runtime.model;
+    if (!model.trim())
+        throw new Error(`setup.model.required: modelo pendente para ${runtime}; informe --model <modelo> neste despacho ou complete o bloco em ork setup.`);
+    const effort = opcoes.effort ??
+        (opcoes.model !== undefined ? 'high' : doBloco?.effort ?? manifesto.runtime.effort);
+    return { runtime, model, effort };
 }
 /** O comando com o prompt mascarado pelo hash: o ledger nao guarda o texto inteiro. */
 function comandoMascarado(comando, sha) {
@@ -194,6 +382,12 @@ function dadosDoDespacho(ctx, comando) {
         promptPath: path.relative(ctx.raiz, ctx.promptPath),
         promptSha256: ctx.promptSha256,
         origem: ctx.origem,
+        // I-36 (T10): a porta por onde o dono chegou. `runtime` e o motor; `canal` e a porta.
+        ...(ctx.canal ? { canal: ctx.canal } : {}),
+        ...(ctx.correlacao ? { correlacao: ctx.correlacao } : {}),
+        ...(ctx.identidade ? { identidade: ctx.identidade } : {}),
+        // I-33 (D4): so identidade e diretorio do perfil; o store guarda o resto e nada e segredo.
+        ...(ctx.perfil ? { perfil: ctx.perfil } : {}),
         comando: comandoMascarado(comando, ctx.promptSha256),
     };
 }
@@ -201,27 +395,36 @@ function dadosDoDespacho(ctx, comando) {
  * Fecha um despacho BEM SUCEDIDO: ledger, decisao autonoma ou pausa prevista, e a
  * sessao gravada no `thread.json`. Usada pelo `ork phase run` e pela retomada do B3.
  */
-function concluirDespacho(ctx, sessionId, verificada, comando) {
+function concluirDespacho(ctx, sessionId, verificada, comando, fonteVerificacao, controlador, 
+/** Variante histórica do supervisor; a variante do controller não tem log próprio. */
+sensores) {
     const dir = (0, thread_1.dirThread)(ctx.raiz, ctx.thread.id);
     const comum = dadosDoDespacho(ctx, comando);
     const bloco = (0, thread_1.blocoDaThread)(ctx.thread, ctx.fase);
     const pausaAoFim = (0, thread_1.pausaNaThread)(ctx.thread, ctx.fase);
-    (0, ledger_1.registrar)(dir, ctx.thread.id, ledger_1.TIPOS_DE_EVENTO.faseDespachada, { ...comum, sessionId });
+    // I-51 (RM-047): a maquina que despachou. So o evento de conducao; os de HITL nao mudam.
+    (0, ledger_1.registrar)(dir, ctx.thread.id, ledger_1.TIPOS_DE_EVENTO.faseDespachada, { ...comum, sessionId, ...(controlador ? { controlador } : {}),
+        maquina: (0, maquina_1.nomeDaMaquina)() });
     (0, ledger_1.registrar)(dir, ctx.thread.id, ledger_1.TIPOS_DE_EVENTO.despachoVerificado, {
         fase: ctx.fase,
         slug: ctx.slug,
         sessionId,
-        fonte: 'claude agents --json',
+        // A fonte e do runtime que despachou: e ela que diz ONDE conferir a sessao depois.
+        fonte: fonteVerificacao ?? (0, runtimes_1.resolverRuntime)(ctx.runtime).fonteVerificacao,
         encontrada: verificada,
     });
     if (!pausaAoFim) {
+        const tag = (0, modos_1.definicaoDoModo)(ctx.thread.modo).tag;
         (0, ledger_1.registrar)(dir, ctx.thread.id, ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma, {
             fase: ctx.fase,
             slug: ctx.slug,
             sessionId,
             decisao: `bloco ${bloco.fases.join('-')} segue sem pausa humana`,
-            autorizadoPor: `#TAG ${(0, modos_1.definicaoDoModo)(ctx.thread.modo).tag} no pedido do builder`,
+            // I-41 (GO-FIX 1, D11): o rastro tipado. `autorizadoPor` fica pelo que ja o lia.
+            quemDecidiu: `o builder, pela #TAG ${tag} no pedido`,
+            autorizadoPor: `#TAG ${tag} no pedido do builder`,
             evidencia: `prompt sha256 ${ctx.promptSha256}`,
+            razao: `o modo ${tag} não prevê pausa humana ao fim do bloco ${bloco.fases.join('-')}`,
         });
     }
     else {
@@ -234,6 +437,7 @@ function concluirDespacho(ctx, sessionId, verificada, comando) {
         });
     }
     const sessao = {
+        ...(controlador ? { controlador } : {}),
         slug: ctx.slug,
         fase: ctx.fase,
         bloco: bloco.fases.join('-'),
@@ -243,23 +447,110 @@ function concluirDespacho(ctx, sessionId, verificada, comando) {
         promptPath: path.relative(ctx.raiz, ctx.promptPath),
         promptSha256: ctx.promptSha256,
         verificada,
+        ...(ctx.perfil ? { perfil: ctx.perfil } : {}),
+        ...(ctx.canal ? { canal: ctx.canal } : {}),
+        ...(ctx.correlacao ? { correlacao: ctx.correlacao } : {}),
     };
     ctx.thread.sessoes.push(sessao);
+    // `ultimoUso` e informativo: store indisponivel nao desfaz um despacho ja provado.
+    if (ctx.perfil) {
+        try {
+            (0, runtime_profiles_1.registrarUsoDePerfil)(ctx.raiz, ctx.perfil.id, sessao.despachadaEm);
+        }
+        catch { /* informativo */ }
+    }
     ctx.thread.faseAtual = ctx.fase;
     (0, thread_1.gravarThread)(ctx.raiz, ctx.thread);
+    // I-36 (T7): a conducao deixa de ser do ato de despachar e passa a ser da janela da sessao.
+    vincularConducaoDaSessao(ctx, sessionId);
+    // I-51 (RM-047): as outras maquinas veem a fase nova; so com a fabrica compartilhada.
+    (0, fabrica_publicar_1.publicarEmSegundoPlano)(ctx.raiz);
+    if (ctx.runtime === 'codex' || ctx.runtime === 'claude-bg')
+        registrarObservacao(ctx, sessao, dir, controlador, sensores);
     return sessao;
 }
+/**
+ * I-36 (T7): o lease de execucao sobrevive ao `ork phase run`, porque quem executa e a sessao. Ele
+ * so sai quando a fase termina (a prova da I-34 no ledger) ou com prova de abandono (D7).
+ */
+function vincularConducaoDaSessao(ctx, sessionId) {
+    const sessao = { sessionId, runtime: ctx.runtime, perfil: ctx.perfil?.id ?? null };
+    const prazoMs = ctx.prazoDaSessaoMs ?? conducao_1.PRAZO_DE_SESSAO_PADRAO_MS;
+    if (ctx.conducao) {
+        ctx.conducao.converterEmSessao({ ...sessao, prazoMs });
+        return;
+    }
+    try {
+        (0, conducao_1.registrarConducaoDaSessao)(ctx.raiz, ctx.thread.id, { canal: ctx.canal ?? 'cli', correlacao: ctx.correlacao ?? null,
+            operacao: ctx.origem.startsWith('retry') ? 'retry.run' : 'phase.run', fase: ctx.fase, promptSha256: ctx.promptSha256,
+            identidade: ctx.identidade?.dispatchId ?? null, prazoMs }, sessao);
+    }
+    catch { /* a conducao protege a worktree; um despacho ja provado nao se desfaz por falta dela */ }
+}
+/** I-36: o prazo do lease de uma sessao do bloco: o limite de duracao dele, ou o padrao. */
+function prazoDaSessao(limites) {
+    return limites?.duracaoMs ? limites.duracaoMs + conducao_1.MARGEM_DO_PRAZO_MS : conducao_1.PRAZO_DE_SESSAO_PADRAO_MS;
+}
+/**
+ * D4: registro da fonte e arranque do observador no ponto comum a `phase` e `retry`.
+ * Sem CLI manual e sem segundo runtime: quem despacha e prova a sessao inicia a observacao.
+ */
+function registrarObservacao(ctx, sessao, dir, controlador, sensores) {
+    const mesmoDespacho = (e) => e.sessionId === sessao.sessionId && e.despachoEm === sessao.despachadaEm;
+    try {
+        // I-34: claude-bg observa pela fonte nativa; no PLAN o registro guarda o sha de base do artefato.
+        // I-33 (N1): o GO codex registra o HEAD do despacho, como a fonte claude-bg; sem ele a D11c nao ve commit pelo shell.
+        const head = ctx.runtime === 'codex' && ctx.fase === 'GO' ? { head: ctx.headNoDespacho ?? null } : {};
+        const fonte = ctx.runtime === 'claude-bg' ? (0, session_watcher_claude_1.fonteClaudeDoDespacho)(ctx.raiz, ctx.thread.id, ctx.fase, ctx.cwd)
+            : sensores?.logPath ? { logPath: sensores.logPath, processoPath: sensores.processoPath, reciboPath: sensores.reciboPath, ...head }
+                : controlador ? { controlador, cwd: ctx.cwd, ...head } : null;
+        if (!fonte)
+            return;
+        (0, session_watcher_1.validarFonteWatcher)(ctx.raiz, sessao.sessionId, fonte);
+        const eventos = (0, ledger_1.lerLedger)(dir);
+        if (!eventos.some(e => e.tipo === 'session_sensor_registered' && mesmoDespacho(e))) {
+            (0, ledger_1.registrar)(dir, ctx.thread.id, 'session_sensor_registered', { fase: ctx.fase,
+                sessionId: sessao.sessionId, despachoEm: sessao.despachadaEm, ...fonte, ...(ctx.perfil ? { perfil: ctx.perfil } : {}) });
+        }
+        // A primitiva verifica identidade/prontidao e ignora registros antigos sem prova.
+        (0, session_watcher_1.iniciarWatcher)(ctx.raiz, sessao.sessionId);
+    }
+    catch {
+        (0, ledger_1.registrar)(dir, ctx.thread.id, 'session_watcher_error', { fase: ctx.fase, sessionId: sessao.sessionId,
+            despachoEm: sessao.despachadaEm, motivo: 'runtime.unavailable', erro: 'fonte ou prontidao do watcher invalida',
+            origem: 'phase.dispatch', ...(controlador ? { controlador } : {}) });
+    }
+}
 /** Despacha a fase pelo runtime adapter e registra tudo no ledger da thread. */
 function rodarFase(carregado, threadId, opcoes) {
+    const rodar = () => opcoes.dryRun ? rodarFaseSobLock(carregado, threadId, opcoes) :
+        (0, hitl_gates_1.comLockHitl)(carregado.raiz, threadId, () => rodarFaseSobLock(carregado, threadId, opcoes));
+    // I-36 (D2): `--esperar` espera a vez FORA do lock HITL (que serializa respostas do dono) e so
+    // depois repete o pedido. Sem ele, a recusa sai na hora.
+    const prazo = opcoes.esperarMs && opcoes.esperarMs > 0 && !opcoes.dryRun ? Date.now() + opcoes.esperarMs : null;
+    for (;;) {
+        if (prazo)
+            (0, conducao_1.esperarConducaoLivre)(carregado.raiz, threadId, Math.max(0, prazo - Date.now()));
+        const r = rodar();
+        if (r.motivo !== 'conducao.em-andamento' || !prazo || Date.now() >= prazo)
+            return r;
+    }
+}
+function rodarFaseSobLock(carregado, threadId, opcoes) {
     const { raiz, manifesto } = carregado;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const fase = opcoes.fase;
     const dir = (0, thread_1.dirThread)(raiz, thread.id);
     const slug = slugDaSessao(thread, fase);
-    // Resolve UMA vez o par modelo/esforco: o mesmo objeto vai ao runtime adapter, ao
-    // ledger e a resposta do CLI. Resolver duas vezes e o caminho curto para o ledger
-    // dizer um modelo e o `claude --bg` receber outro.
-    const { model, effort } = resolverDespacho(manifesto, opcoes);
+    // Resolve UMA vez o trio runtime/modelo/esforco: o mesmo objeto vai ao runtime adapter,
+    // ao ledger e a resposta do CLI. Resolver duas vezes e o caminho curto para o ledger
+    // dizer um modelo e o runtime receber outro. O setup do bloco (feature #setup) entra
+    // aqui: cada bloco de cada modo pode abrir a sessao com runtime/modelo/esforco proprios.
+    const setup = (0, setup_1.lerSetup)(raiz);
+    const doBloco = (0, setup_1.configDoBloco)(setup, thread.modo, fase);
+    const { runtime, model, effort } = resolverDespacho(manifesto, opcoes, doBloco);
+    const limites = (0, setup_1.limitesDoBloco)(manifesto, setup, thread.modo, fase);
+    const rt = (0, runtimes_1.resolverRuntime)(runtime);
     // Bloco B6: a memoria entra ANTES do hash. O prompt que o ledger carimba e o mesmo que
     // o agente recebe, memoria injetada inclusa.
     const memoria = opcoes.memoria ?? (0, memoria_1.abrirMemoria)(carregado);
@@ -269,8 +560,23 @@ function rodarFase(carregado, threadId, opcoes) {
     // Gate tipado do bloco B1: as policies do manifesto valem ANTES do despacho, em
     // qualquer modo. Prompt reprovado nem chega a ser gravado em disco: gravar um prompt
     // com credencial e criar um segundo vazamento no proprio repositorio.
-    const violacoes = (0, policies_1.avaliarPolicies)(manifesto, { gate: 'phase.dispatch', prompt });
+    // RM-008 (fatia 3): as licoes que viraram policy recebem os fatos da thread, calculados aqui.
+    const blocoDespachado = (0, thread_1.blocoDaThread)(thread, fase);
+    const violacoes = (0, policies_1.avaliarPolicies)(manifesto, {
+        gate: 'phase.dispatch', prompt, threadId: thread.id, modo: thread.modo, fase,
+        bloco: thread.blocos.indexOf(blocoDespachado) + 1,
+        blocoComGo: blocoDespachado.fases.includes('GO'),
+        temBaseline: (0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.baselineGravada),
+        fallbackDoBloco: (0, setup_1.fallbackDoBloco)(setup, thread.modo, fase),
+    });
     const bloqueiam = (0, policies_1.bloqueantes)(violacoes);
+    // Warn registra e segue: o aviso vai ao ledger (fora do ensaio) e o despacho continua.
+    if (!opcoes.dryRun) {
+        for (const v of (0, policies_1.avisos)(violacoes)) {
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.politicaAviso, { gate: 'phase.dispatch', fase, slug,
+                policy: v.policy, detalhe: v.detalhe, correcao: v.correcao, modo: thread.modo });
+        }
+    }
     if (bloqueiam.length > 0) {
         const detalhe = bloqueiam.map((v) => `${v.policy}: ${v.detalhe}`).join('; ');
         // Bloco B3: violacao de CUSTO sai tipada como tal. E o que permite a politica de
@@ -296,6 +602,7 @@ function rodarFase(carregado, threadId, opcoes) {
             verificada: false,
             pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase),
             dryRun: opcoes.dryRun === true,
+            runtime,
             model,
             effort,
             bloqueado: true,
@@ -304,173 +611,327 @@ function rodarFase(carregado, threadId, opcoes) {
             erro: detalhe,
         };
     }
-    (0, util_1.gravar)(promptPath, prompt);
-    // A injecao e evidencia: o ledger diz quantos itens entraram, de que colecao e de onde,
-    // para que "o prompt tinha a decisao D2" seja verificavel depois sem reler o prompt.
-    if (injecao.itens.length > 0) {
-        (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.memoriaInjetada, {
-            fase,
-            slug,
-            regime: injecao.regime,
-            decisoes: injecao.decisoes,
-            licoes: injecao.licoes,
-            regras: injecao.regras,
-            itens: injecao.itens.map((i) => `${i.id}:${i.colecao}:${i.location}`),
-            promptSha256: sha,
-        });
+    // I-43 (D4, viga a): a validacao por runtime diferente e cobrada no MESMO portao
+    // por onde todo despacho ja passa. Trocar um portao por outro no mesmo lugar e a
+    // mudanca que o CHECK consegue conferir lendo um diff.
+    const erroDeRuntime = runtimeCruzadoParaDespacho(thread, fase, runtime);
+    if (erroDeRuntime) {
+        (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: 'runtime.autoconferencia',
+            modo: thread.modo, detalhe: erroDeRuntime, fase, slug,
+            correcao: `ork phase run ${thread.id} CHECK --runtime <outro> --prompt "<pedido>"` });
+        return { thread, slug, promptPath, promptSha256: sha, comando: [], sessionId: null,
+            verificada: false, pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase), dryRun: opcoes.dryRun === true,
+            runtime, model, effort, bloqueado: true, motivo: 'runtime.autoconferencia', violacoes, erro: erroDeRuntime };
     }
-    if (memoria.estado.motivo && memoria.estado.pedido === 'orkmind') {
-        (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.memoriaDegradada, {
-            fase,
-            slug,
-            pedido: memoria.estado.pedido,
-            efetivo: memoria.estado.efetivo,
-            motivo: memoria.estado.motivo,
-            detalhe: memoria.estado.detalhe,
-            correcao: memoria.estado.correcao,
-        });
+    const erroDeEstado = estadoParaDespacho(raiz, thread, opcoes.dryRun);
+    if (erroDeEstado) {
+        (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: 'tree.blocked',
+            modo: thread.modo, detalhe: erroDeEstado, correcao: `ork worktree sync ${thread.id}`, fase, slug });
+        return { thread, slug, promptPath, promptSha256: sha, comando: [], sessionId: null,
+            verificada: false, pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase), dryRun: opcoes.dryRun === true,
+            runtime, model, effort, bloqueado: true, motivo: 'tree.blocked', violacoes, erro: erroDeEstado };
     }
-    const cwd = thread.worktree ?? raiz;
-    const pausaAoFim = (0, thread_1.pausaNaThread)(thread, fase);
-    const resultado = adapter.despachar({
-        prompt,
-        nome: slug,
-        cwd,
-        model,
-        effort,
-        dryRun: opcoes.dryRun,
-    });
-    const ctx = {
-        raiz,
-        thread,
-        fase,
-        slug,
-        promptPath,
-        promptSha256: sha,
-        runtime: manifesto.runtime.adapter,
-        cwd,
-        model,
-        effort,
-        origem: 'phase.run',
+    // I-36 (T7, T14): validado o pedido, a conducao da thread, antes de tocar a worktree. A mesma fase com o
+    // mesmo prompt de quem conduz devolve a sessao em andamento sem chamar o adapter; outro pedido recebe a recusa.
+    const identidade = (0, runtime_context_1.novaIdentidadeDeDespacho)(thread.id, fase);
+    const canal = opcoes.canal ?? (0, conducao_1.canalDoProcesso)();
+    const pedidoDeConducao = { canal, correlacao: opcoes.correlacao ?? null, operacao: 'phase.run', fase,
+        promptSha256: sha, identidade: identidade.dispatchId, prazoMs: prazoDaSessao(limites) };
+    const ocupadaPor = (ocupada, gravarNoLedger) => {
+        const base = { thread, slug, promptPath, promptSha256: sha, comando: [], verificada: false,
+            pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase), dryRun: opcoes.dryRun === true, runtime, model, effort, violacoes: [] };
+        const atual = ocupada.atual;
+        if (ocupada.idempotente && atual) {
+            if (gravarNoLedger)
+                (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.despachoIdempotente, { fase, promptSha256: sha, canal,
+                    sessionId: atual.sessao, conducao: { canal: atual.canal, desde: atual.desde },
+                    razao: 'mesma fase e mesmo prompt de quem ja conduz: a sessao em andamento atende o pedido, sem sessao nova e sem cota' });
+            return { ...base, sessionId: atual.sessao, bloqueado: false, motivo: null, idempotente: true, conducao: atual };
+        }
+        const recusa = (0, conducao_1.recusaDeConducao)(thread.id, atual, pedidoDeConducao);
+        if (gravarNoLedger)
+            (0, conducao_1.registrarRecusa)(raiz, recusa);
+        return { ...base, sessionId: null, bloqueado: true, motivo: 'conducao.em-andamento', erro: recusa.texto, recusa,
+            ...(atual ? { conducao: atual } : {}) };
     };
-    const comum = dadosDoDespacho(ctx, resultado.comando);
+    let conducao = null;
     if (opcoes.dryRun) {
-        return {
+        // O ensaio nao toma nada, mas diz a verdade: com conducao em andamento, o despacho real seria recusado.
+        const atual = (0, conducao_1.conducaoDaThread)(raiz, thread.id);
+        if (atual)
+            return ocupadaPor({ ok: false, idempotente: atual.fase === fase && atual.promptSha256 === sha, atual }, false);
+    }
+    else {
+        const tomada = (0, conducao_1.tomarConducao)(raiz, thread.id, pedidoDeConducao);
+        if (!tomada.ok)
+            return ocupadaPor(tomada, true);
+        conducao = tomada;
+    }
+    try {
+        const cwd = thread.worktree ?? raiz;
+        let contextoRuntime;
+        try {
+            contextoRuntime = (0, runtime_context_1.contextoDoProjeto)(raiz, runtime, cwd, thread.id);
+        }
+        catch (e) {
+            const erro = `runtime.unavailable: ${e.message}`;
+            (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: 'runtime.unavailable',
+                modo: thread.modo, detalhe: erro, fase, slug });
+            return { thread, slug, promptPath, promptSha256: sha, comando: [], sessionId: null,
+                verificada: false, pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase), dryRun: opcoes.dryRun === true,
+                runtime, model, effort, bloqueado: true, motivo: 'runtime.unavailable', violacoes, erro };
+        }
+        if (contextoRuntime)
+            contextoRuntime.identidade = identidade;
+        (0, util_1.gravar)(promptPath, prompt);
+        // I-33 (D2, D4, D7): o perfil sai do store com o login conferido. Sem perfil disponivel, o
+        // despacho nao sai pela conta errada: o prompt ja gravado fica registrado para a rotacao do
+        // retry (outro runtime da ordem de fallback, ou a fila), com o motivo tipado.
+        let escolha;
+        try {
+            escolha = perfilParaDespacho(carregado, thread, fase, runtime, { perfil: opcoes.perfil, dryRun: opcoes.dryRun, origem: 'phase.run' });
+        }
+        catch (e) {
+            escolha = { perfil: null, configurados: 0, erro: e.message };
+        }
+        if (escolha.erro) {
+            const motivo = escolha.motivo ?? 'runtime.unavailable';
+            const erro = `${motivo}: ${escolha.erro}`;
+            if (!opcoes.dryRun) {
+                const semPerfil = { identidade, raiz, thread, fase, slug, promptPath, promptSha256: sha, runtime, cwd, model, effort,
+                    origem: 'phase.run', canal, correlacao: opcoes.correlacao ?? null };
+                (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.despachoFalhou, { ...dadosDoDespacho(semPerfil, []), erro });
+                (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo, modo: thread.modo, detalhe: erro,
+                    correcao: motivo === 'cost.violation'
+                        ? 'refaca o login do perfil pela assinatura (claude auth login --claudeai ou codex login com ChatGPT) e rode ork accounts check; perfil de provider pago nunca despacha'
+                        : 'ork accounts list mostra o estado de cada perfil; ork retry run segue pela ordem de fallback ou pela fila',
+                    fase, slug, runtime, origem: 'phase.run' });
+            }
+            return { thread, slug, promptPath, promptSha256: sha, comando: [], sessionId: null,
+                verificada: false, pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase), dryRun: opcoes.dryRun === true,
+                runtime, model, effort, bloqueado: true, motivo, violacoes, erro };
+        }
+        const perfil = escolha.perfil ?? undefined;
+        // A injecao e evidencia: o ledger diz quantos itens entraram, de que colecao e de onde,
+        // para que "o prompt tinha a decisao D2" seja verificavel depois sem reler o prompt.
+        if (injecao.itens.length > 0) {
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.memoriaInjetada, {
+                fase,
+                slug,
+                regime: injecao.regime,
+                decisoes: injecao.decisoes,
+                licoes: injecao.licoes,
+                regras: injecao.regras,
+                itens: injecao.itens.map((i) => `${i.id}:${i.colecao}:${i.location}`),
+                promptSha256: sha,
+            });
+        }
+        if (memoria.estado.motivo && memoria.estado.pedido === 'orkmind') {
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.memoriaDegradada, {
+                fase,
+                slug,
+                pedido: memoria.estado.pedido,
+                efetivo: memoria.estado.efetivo,
+                motivo: memoria.estado.motivo,
+                detalhe: memoria.estado.detalhe,
+                correcao: memoria.estado.correcao,
+            });
+        }
+        const pausaAoFim = (0, thread_1.pausaNaThread)(thread, fase);
+        const claimsSchema = fase === 'GO' && runtime === 'codex'
+            ? schemaDeClaimsDoPacote()
+            : undefined;
+        // I-33 (N1): lido antes de a sessao existir; depois dela, um commit rapido ja estaria no HEAD.
+        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(dir, 'sessoes'),
+            vinculo: { thread: thread.id, fase, promptSha256: sha },
+            contextoRuntime,
+            ...(perfil ? { perfil } : {}),
+            ...(fase === 'PLAN' ? { colaboracao: 'plan' } : {}),
+            ...(claimsSchema ? { outputSchema: claimsSchema } : {}),
+            // `thread.base.branch` vira a branch fonte quando a thread ganha worktree
+            // (`ork/<slug>`). O review nativo precisa comparar essa fonte com a base de
+            // integração do projeto; usar a própria fonte produz um diff vazio.
+            ...(fase === 'CHECK' && runtime === 'codex' ? { reviewBaseBranch: manifesto.worktree.base_branch } : {}),
+            ...(limites ? { duracaoMaximaMs: limites.duracaoMs } : {}),
+            // I-36 (D4): a sessao filha herda a identidade do despacho e o canal; e assim que ela reentra.
+            ambienteExtra: (0, conducao_1.ambienteDaConducao)(identidade.dispatchId, thread.id, canal),
+        });
+        const ctx = {
+            identidade,
+            canal,
+            correlacao: opcoes.correlacao ?? null,
+            ...(conducao ? { conducao } : {}),
+            prazoDaSessaoMs: pedidoDeConducao.prazoMs,
+            raiz,
             thread,
+            fase,
             slug,
             promptPath,
             promptSha256: sha,
-            comando: resultado.comando,
-            sessionId: null,
-            verificada: false,
-            pausaAoFim,
-            dryRun: true,
-            // O ensaio NAO toca no ledger (a garantia do B0 continua de pe), mas devolve o
-            // par resolvido: e assim que o `--dry-run` mostra o modelo que seria despachado.
+            runtime,
+            cwd,
             model,
             effort,
-            bloqueado: false,
-            motivo: null,
-            violacoes,
+            origem: 'phase.run',
+            ...(perfil ? { perfil } : {}),
+            ...(headNoDespacho !== undefined ? { headNoDespacho } : {}),
         };
-    }
-    if (!resultado.ok || !resultado.sessionId) {
-        const erro = resultado.erro ?? 'sem sessionId na saida do runtime';
-        (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.despachoFalhou, {
-            ...comum,
-            erro,
-            stderr: resultado.stderr.slice(0, 500),
-        });
-        // Bloco B3: rate limit nao e falha seca. A fase morreu com HORA de volta, entao ela
-        // vira pedido na fila duravel em vez de virar tarefa da memoria de alguem. O prompt
-        // ja esta gravado em disco com o sha256 acima, e e ele que sera redespachado.
-        const sinal = resultado.rateLimit ?? null;
-        if (sinal) {
-            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.rateLimitDetectado, {
-                fase,
-                slug,
-                fonte: sinal.fonte,
-                resetEm: sinal.resetEm,
-                trecho: sinal.trecho,
-                evidencia: 'stderr real do runtime adapter, nao relato do agente',
-            });
-            const pedido = (0, ratelimit_1.enfileirar)(carregado, {
-                thread: thread.id,
-                fase,
+        const comum = dadosDoDespacho(ctx, resultado.comando);
+        if (opcoes.dryRun) {
+            return {
+                thread,
                 slug,
                 promptPath,
                 promptSha256: sha,
-                cwd,
+                comando: resultado.comando,
+                sessionId: null,
+                verificada: false,
+                pausaAoFim,
+                dryRun: true,
+                // O ensaio NAO toca no ledger (a garantia do B0 continua de pe), mas devolve o
+                // par resolvido: e assim que o `--dry-run` mostra o modelo que seria despachado.
+                runtime,
                 model,
                 effort,
-                sinal,
-                detalhe: erro,
-            });
-            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.rateLimitEnfileirado, {
-                fase,
-                slug,
-                pedido: pedido.id,
-                liberaEm: pedido.liberaEm,
-                janelaEstimada: pedido.janelaEstimada,
-                fonte: sinal.fonte,
-                promptSha256: sha,
-                correcao: `ork retry resume (ou aguarde ate ${pedido.liberaEm})`,
+                bloqueado: false,
+                motivo: null,
+                violacoes,
+            };
+        }
+        if (!resultado.ok || !resultado.sessionId) {
+            const erro = resultado.erro ?? 'sem sessionId na saida do runtime';
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.despachoFalhou, {
+                ...comum,
+                controlador: resultado.controlador,
+                erro,
+                stderr: resultado.stderr.slice(0, 500),
             });
+            // I-33 (D1, D5): a CONTA recusou o despacho. Nada rodou, entao nada foi produzido: o perfil
+            // sai do rodizio e o gate tipado fica para a rotacao do retry, que redespacha o mesmo prompt.
+            const falha = resultado.falhaDeConta ?? null;
+            if (falha) {
+                try {
+                    (0, ratelimit_1.marcarContaDaFalha)(carregado, perfil, falha);
+                }
+                catch { /* o gate abaixo continua registrando a falha */ }
+                (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: falha.motivo, modo: thread.modo, detalhe: erro,
+                    correcao: 'ork retry run rotaciona para o proximo perfil, para o runtime de fallback ou para a fila', fase, slug,
+                    runtime, origem: 'phase.run', falhaDeConta: falha, ...(perfil ? { perfil } : {}),
+                    evidencia: 'saida real do runtime adapter no despacho, nao relato do agente' });
+                return { thread, slug, promptPath, promptSha256: sha, comando: resultado.comando, controlador: resultado.controlador,
+                    sessionId: null, verificada: false, pausaAoFim, dryRun: false, runtime, model, effort, bloqueado: false,
+                    motivo: falha.motivo, violacoes, naFila: null, erro };
+            }
+            // Bloco B3: rate limit nao e falha seca. A fase morreu com HORA de volta, entao ela
+            // vira pedido na fila duravel em vez de virar tarefa da memoria de alguem. O prompt
+            // ja esta gravado em disco com o sha256 acima, e e ele que sera redespachado.
+            const sinal = resultado.rateLimit ?? null;
+            if (sinal) {
+                (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.rateLimitDetectado, {
+                    fase,
+                    slug,
+                    fonte: sinal.fonte,
+                    resetEm: sinal.resetEm,
+                    trecho: sinal.trecho,
+                    evidencia: 'stderr real do runtime adapter, nao relato do agente',
+                });
+                const pedido = (0, ratelimit_1.enfileirar)(carregado, {
+                    thread: thread.id,
+                    fase,
+                    slug,
+                    promptPath,
+                    promptSha256: sha,
+                    cwd,
+                    model,
+                    effort,
+                    sinal,
+                    detalhe: erro,
+                });
+                (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.rateLimitEnfileirado, {
+                    fase,
+                    slug,
+                    pedido: pedido.id,
+                    liberaEm: pedido.liberaEm,
+                    janelaEstimada: pedido.janelaEstimada,
+                    fonte: sinal.fonte,
+                    promptSha256: sha,
+                    correcao: `ork retry resume (ou aguarde ate ${pedido.liberaEm})`,
+                });
+                return {
+                    thread,
+                    slug,
+                    promptPath,
+                    promptSha256: sha,
+                    comando: resultado.comando,
+                    controlador: resultado.controlador,
+                    sessionId: null,
+                    verificada: false,
+                    pausaAoFim,
+                    dryRun: false,
+                    runtime,
+                    model,
+                    effort,
+                    bloqueado: false,
+                    motivo: 'runtime.rate-limited',
+                    violacoes,
+                    naFila: pedido,
+                    erro,
+                };
+            }
             return {
                 thread,
                 slug,
                 promptPath,
                 promptSha256: sha,
                 comando: resultado.comando,
+                controlador: resultado.controlador,
                 sessionId: null,
                 verificada: false,
                 pausaAoFim,
                 dryRun: false,
+                runtime,
                 model,
                 effort,
                 bloqueado: false,
-                motivo: 'runtime.rate-limited',
+                motivo: 'runtime.unavailable',
                 violacoes,
-                naFila: pedido,
+                naFila: null,
                 erro,
             };
         }
+        concluirDespacho(ctx, resultado.sessionId, resultado.verificada, resultado.comando, rt.fonteVerificacao, resultado.controlador, { logPath: resultado.logPath, processoPath: resultado.processoPath, reciboPath: resultado.reciboPath });
         return {
             thread,
             slug,
             promptPath,
             promptSha256: sha,
             comando: resultado.comando,
-            sessionId: null,
-            verificada: false,
+            sessionId: resultado.sessionId,
+            controlador: resultado.controlador,
+            verificada: resultado.verificada,
             pausaAoFim,
             dryRun: false,
+            runtime,
             model,
             effort,
             bloqueado: false,
-            motivo: 'runtime.unavailable',
+            motivo: null,
             violacoes,
-            naFila: null,
-            erro,
         };
     }
-    concluirDespacho(ctx, resultado.sessionId, resultado.verificada, resultado.comando);
-    return {
-        thread,
-        slug,
-        promptPath,
-        promptSha256: sha,
-        comando: resultado.comando,
-        sessionId: resultado.sessionId,
-        verificada: resultado.verificada,
-        pausaAoFim,
-        dryRun: false,
-        model,
-        effort,
-        bloqueado: false,
-        motivo: null,
-        violacoes,
-    };
+    finally {
+        // Despacho que nao virou sessao devolve a conducao; o que virou ja a entregou a sessao.
+        conducao?.liberar();
+    }
 }
 /** Tabela de `ork phase list`: o historico do ledger da thread. */
 function tabelaDoLedger(raiz, threadId) {
@@ -523,7 +984,7 @@ function tabelaDoLedger(raiz, threadId) {
         if (e.cobertura)
             detalhe.push(`cobertura ${String(e.cobertura)}`);
         if (e.liberaEm)
-            detalhe.push(`libera em ${String(e.liberaEm)}`);
+            detalhe.push(`libera em ${(0, horario_1.formatarDataHora)(String(e.liberaEm))}`);
         if (e.tentativa !== undefined && e.limite !== undefined) {
             detalhe.push(`tentativa ${String(e.tentativa)}/${String(e.limite)}`);
         }
@@ -555,12 +1016,12 @@ function tabelaDoLedger(raiz, threadId) {
         if (e.erro)
             detalhe.push(`erro: ${String(e.erro)}`);
         if (e.detalhe && !e.decisao)
-            detalhe.push(String(e.detalhe).slice(0, 90));
+            detalhe.push((0, horario_1.localizarTexto)(String(e.detalhe)).slice(0, 90));
         if (e.modo && !e.fase)
             detalhe.push(`modo ${String(e.modo)}`);
-        return [e.ts.replace('T', ' ').slice(0, 19), e.tipo, detalhe.join(' | ')];
+        return [(0, horario_1.formatarDataHora)(e.ts, { segundos: true }), e.tipo, detalhe.join(' | ')];
     });
-    return (0, util_1.tabela)(['QUANDO', 'EVENTO', 'DETALHE'], linhas);
+    return `${(0, util_1.tabela)(['QUANDO', 'EVENTO', 'DETALHE'], linhas)}\n${(0, horario_1.legendaDoFuso)()}`;
 }
 /** Slug legivel por humano de uma sessao (usado nas mensagens do CLI). */
 function descreverSlug(slug) {