@orkastery/cli 0.6.1 → 0.6.3

package/dist/mcp-verify.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ESPERA_DA_FILA_PESADA_MCP_MS = void 0;
+exports.diagnosticoDoVerifyMcp = diagnosticoDoVerifyMcp;
 exports.verificarMcp = verificarMcp;
 /** Operação estruturada: argumentos só identificam a thread; execução sempre confinada. */
 const fs = __importStar(require("node:fs"));
@@ -68,6 +69,14 @@ function mesmoLease(a, b) {
     return !!a && a.nome === b.nome && a.thread === b.thread && a.pid === b.pid &&
         a.adquiridoEm === b.adquiridoEm && a.expiraEm === b.expiraEm && a.motivo === b.motivo;
 }
+/** Parte pura do retorno MCP: permite provar o contrato mesmo quando o sandbox nao abre outro sandbox. */
+function diagnosticoDoVerifyMcp(r) {
+    return {
+        regressoes: r.regressoes.map(c => c.nome),
+        preExistentes: r.preExistentes.map(c => c.nome),
+        comparacoes: r.comparacoes,
+    };
+}
 /** Síncrono: prazo total/per-command, não cancelamento reativo do event loop. */
 function verificarMcp(raizEntrada, threadId, conducao = {}) {
     const deadline = Date.now() + PRAZO_TOTAL_MS;
@@ -167,7 +176,7 @@ function verificarMcp(raizEntrada, threadId, conducao = {}) {
             execucoes: execucoes.slice(0, LIMITE_RETORNO).map(c => ({ nome: c.nome, ok: c.ok, code: c.code,
                 executado: c.executado === true, resumo: c.resumo })),
             totalExecucoes: execucoes.length, omitidas: Math.max(0, execucoes.length - LIMITE_RETORNO),
-            regressoes: r.regressoes.map(c => c.nome), preExistentes: r.preExistentes.map(c => c.nome),
+            ...diagnosticoDoVerifyMcp(r),
             executor: 'codex-sandbox', prazoTotalMs: PRAZO_TOTAL_MS, limitePorComandoMs: COMANDO_MAX_MS,
         };
     }

package/dist/pedido-conducao.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOTIVOS_DE_PEDIDO_A_CONDUCAO = void 0;
+exports.registrarPedidoAConducao = registrarPedidoAConducao;
+/**
+ * Pedido estreito da sessao de fase para a conducao. A sessao nao executa o comando,
+ * nao aprova gate e nao assume o dono: ela apenas registra por que parou e o passo exato.
+ */
+const gates_1 = require("./gates");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+exports.MOTIVOS_DE_PEDIDO_A_CONDUCAO = [
+    'concurrency.lease-indeterminado',
+    'conducao.acao-necessaria',
+];
+function comandoSeguro(comando) {
+    return comando.length <= 1000 && /^ork [^\s]/u.test(comando) && !/[\p{Cc}\p{Cf};|&<>`$\\()]/u.test(comando) &&
+        !/\s{2,}/.test(comando) && comando.trim() === comando;
+}
+/** Registra uma vez, sempre correlacionado ao despacho que originou o servidor MCP filho. */
+function registrarPedidoAConducao(raiz, threadId, entrada) {
+    if (!exports.MOTIVOS_DE_PEDIDO_A_CONDUCAO.includes(entrada.motivo))
+        throw Error('conducao.request.reason.invalid');
+    if (!comandoSeguro(entrada.comando)) {
+        throw Error('conducao.request.command.invalid: informe um comando ork de uma linha, sem operadores de shell');
+    }
+    const thread = (0, thread_1.lerThread)(raiz, threadId), dir = (0, thread_1.dirThread)(raiz, threadId), eventos = (0, ledger_1.lerLedger)(dir);
+    const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' &&
+        e.identidade?.dispatchId === entrada.despacho).at(-1);
+    if (!despacho || despacho.thread !== threadId || typeof despacho.sessionId !== 'string' || typeof despacho.fase !== 'string') {
+        throw Error('conducao.request.dispatch.invalid: o servidor nao corresponde a um despacho provado desta thread');
+    }
+    const sessao = thread.sessoes.find(s => s.sessionId === despacho.sessionId && s.fase === despacho.fase);
+    if (!sessao)
+        throw Error('conducao.request.session.invalid: o despacho nao esta vinculado a sessao ativa da thread');
+    const existente = eventos.filter(e => e.tipo === 'gate_blocked' && e.origem === 'mcp.request_conduction' &&
+        e.despacho === entrada.despacho && e.motivo === entrada.motivo && e.comando === entrada.comando).at(-1);
+    if (existente)
+        return { ok: true, criado: false, eventId: existente.eventId, motivo: entrada.motivo,
+            comando: entrada.comando, fase: despacho.fase, sessionId: despacho.sessionId, despacho: entrada.despacho };
+    const evento = (0, gates_1.registrarGateBloqueado)(dir, threadId, {
+        gate: 'phase.dispatch', motivo: entrada.motivo, modo: thread.modo,
+        detalhe: entrada.detalhe, correcao: entrada.comando,
+        evidencia: `despacho ${entrada.despacho} da sessao ${despacho.sessionId}`,
+        fase: despacho.fase, sessionId: despacho.sessionId, despachoEm: sessao.despachadaEm,
+        despacho: entrada.despacho, comando: entrada.comando, origem: 'mcp.request_conduction',
+        pedidoConducao: { contrato: 'ork.pedido-conducao/v1', host: entrada.host, estado: 'aberto' },
+    });
+    return { ok: true, criado: true, eventId: evento.eventId, motivo: entrada.motivo,
+        comando: entrada.comando, fase: despacho.fase, sessionId: despacho.sessionId, despacho: entrada.despacho };
+}

package/dist/preflight.js

@@ -126,49 +126,46 @@ function sondasDeAmbiente(raiz, umask = umaskDoProcesso()) {
  * com login conferido pelo proprio CLI. A sonda nao marca o store: quem marca e o despacho.
  */
 function checkDeContas(raiz, runtime, auth = authPadrao) {
+    const m = (0, locale_1.msg)().preflight;
     let perfis;
     try {
         perfis = (0, runtime_profiles_1.perfisDoRuntime)((0, runtime_profiles_1.lerPerfisComContas)(raiz), runtime).filter(p => p.estado !== 'desativado');
     }
     catch (e) {
-        return { nome: 'contas', nivel: 'fail', detalhe: `store de perfis invalido: ${e.message}` };
+        return { nome: 'contas', nivel: 'fail', detalhe: m.storeInvalido(e.message) };
     }
     if (!perfis.length)
-        return { nome: 'contas', nivel: 'ok', detalhe: `${runtime} sem perfil configurado: despacho pelo ambiente do processo` };
+        return { nome: 'contas', nivel: 'ok', detalhe: m.semPerfil(runtime) };
     const estados = perfis.map(p => {
         const a = auth((0, runtime_profiles_1.perfilDeDespacho)(p));
         return { id: p.id, pronto: a.ok && (0, runtime_profiles_1.perfilDisponivel)(p),
-            texto: !a.ok ? `${a.pago ? 'provider pago, nunca despacha' : a.transitorio ? 'conferencia de login inconclusiva' : 'sem login'} (${a.detalhe})` : (0, runtime_profiles_1.perfilDisponivel)(p) ? 'pronto' : `${p.estado}${p.esgotadoAte ? ` ate ${p.esgotadoAte}` : ''}` };
+            texto: !a.ok ? `${a.pago ? m.estadoConta.providerPago : a.transitorio ? m.estadoConta.loginInconclusivo : m.estadoConta.semLogin} (${a.detalhe})`
+                : (0, runtime_profiles_1.perfilDisponivel)(p) ? m.estadoConta.pronto : m.estadoConta.esgotadoAte(p.estado, p.esgotadoAte ?? '') };
     });
     const prontos = estados.filter(e => e.pronto).length;
     return { nome: 'contas', nivel: prontos === 0 ? 'fail' : prontos < estados.length ? 'warn' : 'ok',
-        detalhe: `${runtime}: ${estados.map(e => `${e.id} ${e.texto}`).join('; ')}`,
-        ...(prontos < estados.length ? { correcao: 'ork accounts check marca os perfis; ork accounts add refaz o login pelo proprio CLI' } : {}) };
+        detalhe: m.contas(runtime, estados.map(e => `${e.id} ${e.texto}`).join('; ')),
+        ...(prontos < estados.length ? { correcao: m.contasCorrecao } : {}) };
 }
-const limites = [
-    'Sonda contextual local: não inventaria sessões, não inicia modelo e não autoriza despacho.',
-    'Aceitação do modelo, instalação do adaptador/MCP, contexto da thread, gates e policies do pedido são revalidados no despacho; com perfis, o login de cada conta é conferido aqui e de novo no despacho.',
-    'Trio sem override; um override posterior exige resolver e verificar novamente o despacho.',
-    'VERIFY/SHIP MCP exigem executor Codex isolado próprio e transporte SHIP válido; a sonda de despacho não comprova entrega.',
-];
 function preflight(raiz, modo, nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)(), sensores = sensoresPadrao) {
+    const t = (0, locale_1.msg)().preflight;
     // I-43: a matriz tem os cinco (para LER thread antiga); quem entra aqui e ESCRITA.
     if (!modos_1.ORDEM_DOS_MODOS.includes(modo))
         throw Error('preflight.mode.invalid');
     const checks = [];
-    checks.push({ nome: 'node', nivel: Number(process.versions.node.split('.')[0]) >= 20 ? 'ok' : 'fail', detalhe: 'Node 20 ou superior necessário' });
+    checks.push({ nome: 'node', nivel: Number(process.versions.node.split('.')[0]) >= 20 ? 'ok' : 'fail', detalhe: t.node });
     const git = !!(0, util_1.noPath)('git');
-    checks.push({ nome: 'git', nivel: git ? 'ok' : 'fail', detalhe: git ? 'Git disponível' : 'Git ausente' });
+    checks.push({ nome: 'git', nivel: git ? 'ok' : 'fail', detalhe: git ? t.gitOk : t.gitAusente });
     const repo = git ? (0, util_1.exec)('git', ['rev-parse', '--is-inside-work-tree'], raiz, 10000) : null;
-    checks.push({ nome: 'repositorio', nivel: repo?.ok && repo.stdout.trim() === 'true' ? 'ok' : 'fail', detalhe: 'Repositório Git local necessário' });
+    checks.push({ nome: 'repositorio', nivel: repo?.ok && repo.stdout.trim() === 'true' ? 'ok' : 'fail', detalhe: t.repo });
     checks.push(...sondasDeAmbiente(raiz));
     const carregado = (0, manifest_1.carregarManifesto)(raiz);
     const blocos = [];
-    checks.push({ nome: 'manifesto', nivel: !carregado || carregado.erros.length ? 'fail' : 'ok', detalhe: !carregado ? 'Manifesto ausente' : carregado.erros.length ? 'Manifesto inválido; corrija antes do despacho' : 'Manifesto válido' });
+    checks.push({ nome: 'manifesto', nivel: !carregado || carregado.erros.length ? 'fail' : 'ok', detalhe: !carregado ? t.manifestoAusente : carregado.erros.length ? t.manifestoInvalido : t.manifestoValido });
     if (carregado && !carregado.erros.length) {
         const m = carregado.manifesto;
-        checks.push({ nome: 'modo', nivel: m.conduction.allowed_modes.includes(modo) ? 'ok' : 'fail', detalhe: `Modo solicitado: ${modo}` });
-        checks.push({ nome: 'abbrev', nivel: (0, slug_1.validarAbbrev)(m.project.abbrev).ok ? 'ok' : 'fail', detalhe: 'Identidade curta do projeto validada' });
+        checks.push({ nome: 'modo', nivel: m.conduction.allowed_modes.includes(modo) ? 'ok' : 'fail', detalhe: t.modo(modo) });
+        checks.push({ nome: 'abbrev', nivel: (0, slug_1.validarAbbrev)(m.project.abbrev).ok ? 'ok' : 'fail', detalhe: t.abbrev });
         const setup = (0, setup_1.lerSetup)(carregado.raiz), observados = new Map(), contas = new Map();
         let sandbox;
         for (const [i, bloco] of modos_1.MODOS[modo].blocos.entries()) {
@@ -177,11 +174,11 @@ function preflight(raiz, modo, nomesHerdados = (0, runtime_ambiente_1.nomesDePro
             try {
                 trio = (0, phase_1.resolverDespacho)(m, {}, (0, setup_1.configDoBloco)(setup, modo, bloco.fases[0]));
                 (0, runtimes_1.resolverRuntime)(trio.runtime);
-                locais.push({ nome: 'trio', nivel: 'ok', detalhe: 'Runtime/modelo/esforço resolvidos pelo mesmo contrato do despacho; aceitação nativa não comprovada' });
+                locais.push({ nome: 'trio', nivel: 'ok', detalhe: t.trio });
                 if (!observados.has(trio.runtime))
                     observados.set(trio.runtime, sensores.runtime(trio.runtime));
                 const presente = observados.get(trio.runtime);
-                locais.push({ nome: 'runtime', nivel: presente ? 'ok' : 'fail', detalhe: presente ? `${trio.runtime} disponível` : `${trio.runtime} ausente` });
+                locais.push({ nome: 'runtime', nivel: presente ? 'ok' : 'fail', detalhe: presente ? t.runtimeOk(trio.runtime) : t.runtimeAusente(trio.runtime) });
                 if (presente) {
                     if (!contas.has(trio.runtime))
                         contas.set(trio.runtime, checkDeContas(carregado.raiz, trio.runtime, sensores.auth ?? authPadrao));
@@ -189,14 +186,15 @@ function preflight(raiz, modo, nomesHerdados = (0, runtime_ambiente_1.nomesDePro
                 }
                 if (trio.runtime === 'codex' && presente) {
                     sandbox ??= sensores.sandboxCodex();
-                    locais.push({ nome: 'sandbox de despacho', nivel: sandbox ? 'ok' : m.runtime.sandbox === 'danger-full-access' ? 'warn' : 'fail', detalhe: sandbox ? 'Sonda Codex sem modelo executou' : 'Sonda Codex falhou; não altere o sandbox para contornar a falha' });
+                    locais.push({ nome: 'sandbox de despacho', nivel: sandbox ? 'ok' : m.runtime.sandbox === 'danger-full-access' ? 'warn' : 'fail', detalhe: sandbox ? t.sandboxOk : t.sandboxFalhou });
                 }
                 const ativos = nomesHerdados.filter(n => runtime_ambiente_1.ENVS_DE_PROVIDER_PAGO.includes(n));
                 const relevantes = ativos.filter(n => trio.runtime === 'claude-bg' ? /^(ANTHROPIC_|CLAUDE_CODE_USE_)/.test(n) : /^(OPENAI_|OPENROUTER_)/.test(n));
-                locais.push({ nome: 'provider', nivel: m.runtime.provider_policy === 'subscription-only' && relevantes.length ? 'fail' : ativos.length ? 'warn' : 'ok', detalhe: relevantes.length ? `Nomes de provider incompatíveis com assinatura: ${relevantes.join(', ')}` : ativos.length ? 'Há nomes de provider alheios ao runtime; não usar credenciais pagas' : 'Nenhum nome de provider pago ativo' });
+                locais.push({ nome: 'provider', nivel: m.runtime.provider_policy === 'subscription-only' && relevantes.length ? 'fail' : ativos.length ? 'warn' : 'ok',
+                    detalhe: relevantes.length ? t.providerIncompativel(relevantes.join(', ')) : ativos.length ? t.providerAlheio : t.providerNenhum });
             }
             catch {
-                locais.push({ nome: 'trio', nivel: 'fail', detalhe: 'Setup/trio ou sonda inválidos; complete o modelo e confira o runtime no setup canônico' });
+                locais.push({ nome: 'trio', nivel: 'fail', detalhe: t.trioInvalido });
             }
             blocos.push({ numero: i + 1, fases: [...bloco.fases], trio, checks: locais, pronto: locais.every(c => c.nivel !== 'fail') });
         }
@@ -205,16 +203,17 @@ function preflight(raiz, modo, nomesHerdados = (0, runtime_ambiente_1.nomesDePro
     return { modo, scope: 'dispatch-local', checks, blocos,
         prontoPrimeiroBloco: basePronta && !!blocos[0]?.pronto,
         prontoTodosBlocos: basePronta && blocos.length > 0 && blocos.every(b => b.pronto),
-        entrega: { verificada: false, dependencias: ['executor Codex isolado', 'transporte SHIP instalado', 'gates e HEADs correntes'] }, limites: [...limites] };
+        entrega: { verificada: false, dependencias: ['executor Codex isolado', 'transporte SHIP instalado', 'gates e HEADs correntes'] }, limites: [...t.limites] };
 }
 function textoPreflight(r) {
     // I-35: o Check guarda o ISO (dado de maquina); quem imprime para o dono localiza.
     let localizou = false;
     const local = (t) => { const l = (0, horario_1.localizarTexto)(t); if (l !== t)
         localizou = true; return l; };
-    const linhas = ['ork doctor contextual: ' + r.modo, ...r.checks.map(c => `${c.nivel}: ${c.nome}: ${local(c.detalhe)}`),
-        ...r.blocos.flatMap(b => [`bloco ${b.numero} ${b.fases.join('→')}: ${b.trio ? `${b.trio.runtime}/${b.trio.model}/${b.trio.effort}` : 'trio pendente'}`, ...b.checks.map(c => `  ${c.nivel}: ${c.nome}: ${local(c.detalhe)}`)]),
-        `Primeiro bloco: ${r.prontoPrimeiroBloco ? 'sonda pronta' : 'bloqueado'}; todos os blocos: ${r.prontoTodosBlocos ? 'sonda pronta' : 'dependências pendentes'}`, ...r.limites];
+    const m = (0, locale_1.msg)().preflight, nome = (v) => m.nomes[v] ?? v;
+    const linhas = [m.titulo(r.modo), ...r.checks.map(c => m.check(c.nivel, nome(c.nome), local(c.detalhe))),
+        ...r.blocos.flatMap(b => [m.bloco(b.numero, b.fases.join('→'), b.trio ? `${b.trio.runtime}/${b.trio.model}/${b.trio.effort}` : null),
+            ...b.checks.map(c => m.checkDoBloco(c.nivel, nome(c.nome), local(c.detalhe)))]), m.resumo(r.prontoPrimeiroBloco, r.prontoTodosBlocos), ...r.limites];
     // O fuso sai uma vez por mensagem, depois dos limites.
     if (localizou)
         linhas.push((0, horario_1.legendaDoFuso)());

package/dist/prompts.js

@@ -292,7 +292,7 @@ function lintTemplate(t, contrato) {
  */
 exports.TEMPLATE_FASE_PADRAO = `---
 id: fase-padrao
-versao: 4
+versao: 5
 descricao: Prompt canonico de uma fase do ciclo GOAL..MASTER, com nomenclatura, modo de conducao, contexto da thread, memoria injetada e regras de evidencia.
 fases: [GOAL, PLAN, GO, CHECK, SHIP, MASTER]
 variaveis: [fase, thread, bloco, nome, ciclo_canonico, tag, blocos, pausas, linha_variante, regra_de_pausa, invariantes, slug, projeto_nome, projeto_abbrev, base_branch, base_commit, diretorio, trabalho, pedido, fecho_go, memoria_injetada, regras_de_evidencia]
@@ -307,6 +307,7 @@ Quando disponiveis, use ork_artifact_read/write para objetivo, plano e parecer,
 Decisao que voce tomar sem perguntar ao dono vai ao ledger por \`ork decisao registrar <thread>\` (no MCP, \`ork_decision_record\`, pois o sandbox do codex nao grava o ledger), com o que foi decidido, o porque, como mudar, o custo de reverter agora e depois, o criterio escrito, quem decidiu e a evidencia; e assim que ela chega ao dono no resumo, em vez de sumir na conversa.
 Artefato de autoria do agente nao e recibo oficial; cadastrar claim nao significa verifica-la.
 Para registrar produto, prefira ork_git_commit com HEAD atual e paths com claims; use ork_verify para verificacao real e ork_ship com HEADs fonte/destino conferidos para entrega. Commit local nao e SHIP; retorno incomplete exige reconciliar estado e remoto antes de repetir. Permissao para consultar nao concede essas operacoes: respeite a autorizacao nativa e os gates.
+Quando o MCP expuser \`ork_verify_status\`, chame \`ork_verify\` uma vez, guarde o \`rodadaId\` e consulte a mesma rodada a cada 30–60 s. Enquanto ela estiver na fila ou rodando, retenha apenas estado e lane atuais no contexto; nao repita o pedido nem copie payloads intermediarios. So avance com o veredito terminal verde; falha tipada ou veredito vermelho bloqueia o ciclo.
 Decisao do dono deve ser apresentada pela sessao condutora ao host; a sessao filha nao responde nem assume a identidade do dono.
 Preserve o perfil filho configurado: \`interactive\` concede consultas; \`worktree\` exige opt-in da instalacao e autoriza ferramentas exatas na WT validada, sem aprovar gates ou assumir o dono. Nao mude configuracao para contornar bloqueio.
 Consulte \`ork_git_status\` para HEADs reais e estado Git; use \`ork_git_commit\`, \`ork_verify\` e \`ork_ship\` pelos contratos do nucleo, sem Bash Git nem inventar SHAs. Use \`source.head\` como \`expectedHead\` do commit; consulte novamente apos commit e use \`source.head\`/\`destination.head\` como \`expectedSource\`/\`expectedDestination\` do SHIP. Base historica nao substitui a consulta atual. As regras Edit/deny sao permissoes nativas de ferramentas, nao sandbox de processos.
@@ -351,7 +352,7 @@ Falha de autenticação permanece impedimento; não troque provider, sandbox ou
 /** English counterpart of the canonical phase prompt. The pt-BR template above remains the source contract. */
 exports.TEMPLATE_FASE_PADRAO_EN = `---
 id: fase-padrao.en
-versao: 4
+versao: 5
 descricao: Canonical prompt for a GOAL..MASTER cycle phase, with naming, conduction mode, thread context, injected memory, and evidence rules.
 fases: [GOAL, PLAN, GO, CHECK, SHIP, MASTER]
 variaveis: [fase, thread, bloco, nome, ciclo_canonico, tag, blocos, pausas, linha_variante, regra_de_pausa, invariantes, slug, projeto_nome, projeto_abbrev, base_branch, base_commit, diretorio, trabalho, pedido, fecho_go, memoria_injetada, regras_de_evidencia]
@@ -366,6 +367,7 @@ When available, use ork_artifact_read/write for the goal, plan, and review, and
 Record every decision you make without asking the owner in the ledger with \`ork decisao registrar <thread>\` (or \`ork_decision_record\` in MCP because the Codex sandbox cannot write the ledger), including what was decided, why, how to change it, reversal cost now and later, the written criterion, who decided, and the evidence. This is how it reaches the owner in the summary instead of disappearing in the conversation.
 An agent-authored artifact is not an official receipt; registering a claim does not verify it.
 To record product changes, prefer ork_git_commit with the current HEAD and paths with claims; use ork_verify for real verification and ork_ship with checked source/destination HEADs for delivery. A local commit is not SHIP; an incomplete result requires reconciling state and remote before retrying. Permission to query does not grant those operations: respect native authorization and gates.
+When MCP exposes \`ork_verify_status\`, call \`ork_verify\` once, keep its \`rodadaId\`, and query that same round every 30–60 seconds. While queued or running, retain only the current state and lane in context; do not repeat the request or copy intermediate payloads. Continue only after a terminal green verdict; a typed failure or red verdict blocks the cycle.
 The conducting session presents an owner decision to the host; a child session neither answers nor assumes the owner's identity.
 Preserve the configured child profile: \`interactive\` grants queries; \`worktree\` requires installation opt-in and authorizes exact tools in the validated worktree, without approving gates or assuming the owner. Do not change configuration to bypass a block.
 Query \`ork_git_status\` for real HEADs and Git state; use \`ork_git_commit\`, \`ork_verify\`, and \`ork_ship\` through the core contracts, without Bash Git or invented SHAs. Use \`source.head\` as the commit \`expectedHead\`; query again after the commit and use \`source.head\`/\`destination.head\` as SHIP \`expectedSource\`/\`expectedDestination\`. A historical base does not replace the current query. Edit/deny rules are native tool permissions, not process sandbox rules.

package/dist/pulse.js

@@ -157,7 +157,8 @@ function comporPulse(carregado, entrada) {
             if (p.motivo === 'human.pending' && p.fonte === 'ledger' && entregas?.doCondutor.gates.has(`${l.thread}|${p.fase}`))
                 continue;
             if (ehRegistro(l.thread)) {
-                if (p.fonte === 'escalonador' || ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'vaga.stale', 'runtime.silencio'].includes(p.motivo))
+                if (p.fonte === 'escalonador' || ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'vaga.stale',
+                    'runtime.silencio', 'concurrency.lease-indeterminado', 'conducao.acao-necessaria'].includes(p.motivo))
                     continue;
                 const sessoes = radar.sessoes.filter(s => s.thread?.id === l.thread && s.thread.fase === p.fase);
                 // Escalada explícita de ledger não é apagada pela conclusão de uma sessão.
@@ -213,7 +214,8 @@ function comporPulse(carregado, entrada) {
                 }
             }
             // I-45: vaga parada e sinal do escalonador (`ork board reap` devolve a vaga), nao pergunta ao dono.
-            const esperaAutomatica = ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'runtime.rate-limited', 'vaga.stale'].includes(p.motivo);
+            const esperaAutomatica = ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'runtime.rate-limited', 'vaga.stale',
+                'concurrency.lease-indeterminado', 'conducao.acao-necessaria'].includes(p.motivo);
             (esperaAutomatica ? automaticas : humanos).push(item);
         }
     // RM-063 (F5): o MASTER por omissao da varredura nao vira item do dono (I-45: a entrega sem nota fica na faixa

package/dist/rede.js

@@ -73,7 +73,7 @@ exports.painelDaRede = painelDaRede;
  * fora de qualquer clone de projeto.
  *
  * D3: publicar exige o repositorio privado, conferido na forja antes de cada publicacao.
- * D5: o retrato e uma LISTA DE PERMISSAO (maquina, hostname, forjas, runtimes, hosts, projetos,
+ * D5: o retrato e uma LISTA DE PERMISSAO (maquina, alias legado, forjas, runtimes, hosts, projetos,
  * versao do `ork`, batida) e passa por uma varredura de segredo antes do push: um achado recusa a
  * publicacao inteira, e o erro diz o padrao e o campo, nunca o valor.
  * D6: cada maquina so escreve o proprio retrato; o `REDE.md` e indice derivado que quem publica
@@ -191,6 +191,17 @@ function hostnameSeguro() {
     const bruto = os.hostname().trim();
     return /^[A-Za-z0-9][A-Za-z0-9._-]{0,252}$/.test(bruto) ? bruto : bruto.replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 253) || 'desconhecido';
 }
+/**
+ * RM-062 F3: o nome que sai da maquina precisa ter sido escolhido localmente. O fallback historico
+ * para `os.hostname()` transformava um detalhe privado em nome de arquivo e em JSON. A configuracao
+ * fica em `~/.orkastery/maquina.json`; `--maquina` e `ORK_MAQUINA` cobrem a primeira entrada.
+ */
+function nomeGenericoDaRede(explicito) {
+    const nome = (explicito ?? '').trim() || (0, maquina_1.lerConfigDaMaquina)()?.nome || (process.env.ORK_MAQUINA ?? '').trim();
+    if (!nome)
+        throw new locale_1.ErroDoCatalogo((m) => m.network.nomeGenericoAusente);
+    return nomeSeguro(nome);
+}
 /** O retrato desta maquina, montado so com os campos da lista de permissao (D5). */
 function retratoDaMaquina(opcoes = {}) {
     return retratoComDescartes(opcoes).retrato;
@@ -199,7 +210,7 @@ function retratoDaMaquina(opcoes = {}) {
  * O retrato e os projetos que ficaram fora dele. Projeto vem de fora do nucleo (o registro da
  * RM-052, o cwd, o ultimo retrato): um valor dele com cara de segredo tira SO aquele projeto, com
  * aviso, em vez de travar a publicacao da maquina para sempre (A1 do CHECK 1). O que o nucleo monta
- * (maquina, hostname, forjas, runtimes, hosts) continua falhando fechado em `exigirRetratoSeguro`.
+ * (maquina, alias legado, forjas, runtimes, hosts) continua falhando fechado em `exigirRetratoSeguro`.
  */
 function retratoComDescartes(opcoes = {}) {
     const amb = opcoes.amb ?? {};
@@ -248,11 +259,12 @@ function retratoComDescartes(opcoes = {}) {
         descartados.push({ campo: `projetos[${exports.MAXIMO_DE_ITENS}..]`, padrao: `limite de ${exports.MAXIMO_DE_ITENS} projetos` });
         limpos.length = exports.MAXIMO_DE_ITENS;
     }
+    const maquina = nomeGenericoDaRede(opcoes.maquina);
     const retrato = {
         contrato: exports.CONTRATO_DO_RETRATO,
-        maquina: nomeSeguro((0, maquina_1.nomeDaMaquina)(opcoes.maquina)),
+        maquina,
         ...(opcoes.id ? { id: opcoes.id } : {}),
-        hostname: hostnameSeguro(),
+        hostname: maquina,
         adesao: opcoes.adesao ?? (0, rede_adesao_1.adesaoDaRede)().adesao ?? 'rede',
         forjas: identidades.map((i) => ({ forja: i.forja, host: i.host, cli: i.cli, versao: i.versao, usuario: i.usuario })),
         runtimes,
@@ -785,10 +797,9 @@ function gravarNaCasa(conferida, retrato, descartados, opcoes) {
             const idDoOutro = atual ? atual.id ?? null : idNoArquivo(cache, ponta, arquivoDoRetrato(maquina));
             const alheio = !!idDoOutro && idDoOutro !== retrato.id;
             if (alheio && !opcoes.tomarNome) {
-                // U7 da revisao 3: o hostname igual sugere a propria maquina, mas duas VMs podem se chamar `ubuntu`.
-                const mesmoHostname = atual?.hostname === hostnameSeguro();
+                // O campo legado `hostname` agora repete o alias generico e nao distingue instalacoes.
                 const outro = atual ? { hostname: atual.hostname, publicadoEm: atual.publicadoEm } : null;
-                throw new locale_1.ErroDoCatalogo((m) => m.network.nomeEmUso(maquina, outro ? m.network.quemHostname(String(outro.hostname), (0, horario_1.formatarDataHora)(outro.publicadoEm)) : m.network.quemIlegivel, mesmoHostname ? m.network.dicaMesmoHostname : m.network.dicaOutroNome));
+                throw new locale_1.ErroDoCatalogo((m) => m.network.nomeEmUso(maquina, outro ? m.network.quemHostname(String(outro.hostname), (0, horario_1.formatarDataHora)(outro.publicadoEm)) : m.network.quemIlegivel, m.network.dicaNomeEmUso));
             }
             const mudancas = [
                 { caminho: arquivoDoRetrato(maquina), conteudo: JSON.stringify(retrato, null, 2) + '\n' },
@@ -819,7 +830,7 @@ function publicarRede(opcoes = {}) {
     if (!adesao.membro)
         throw new locale_1.ErroDoCatalogo((m) => m.network.foraDaRede);
     const amb = opcoes.amb ?? {};
-    const maquina = nomeSeguro((0, maquina_1.nomeDaMaquina)(opcoes.maquina));
+    const maquina = nomeGenericoDaRede(opcoes.maquina);
     const id = (0, rede_adesao_1.idDaMaquina)();
     const agora = opcoes.agora ?? new Date().toISOString();
     const marca = lerMarcaDaRede();
@@ -860,12 +871,13 @@ const NOME_DE_MAQUINA = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
  * `ork network entrar`. M2 do CHECK 1: atomico do ponto de vista da maquina. Confere (e cria,
  * privada) a casa, publica o primeiro retrato e SO ENTAO grava o nome e a adesao; se a publicacao
  * falha, nada muda aqui. M3: o nome que vale e gravado, como no `ork fabrica entrar`: `--maquina`,
- * senao o ja gravado, senao `ORK_MAQUINA` ou o hostname; assim o cron publica com o mesmo nome.
+ * senao o ja gravado, senao `ORK_MAQUINA`; assim o cron publica com o mesmo nome. RM-062 F3:
+ * hostname nunca e fallback, porque nome de arquivo e JSON sao evidencia publicada.
  */
 function entrarNaRede(opcoes = {}) {
-    // O nome explicito tem de ser valido; o que vem do arquivo, de ORK_MAQUINA ou do hostname e saneado.
+    // O nome explicito tem de ser valido; o que vem do arquivo ou de ORK_MAQUINA e saneado.
     const explicito = (opcoes.maquina ?? '').trim();
-    const maquina = explicito || nomeSeguro((0, maquina_1.lerConfigDaMaquina)()?.nome || (0, maquina_1.nomeDaMaquina)());
+    const maquina = explicito || nomeGenericoDaRede();
     if (!NOME_DE_MAQUINA.test(maquina)) {
         throw new locale_1.ErroDoCatalogo((m) => m.network.nomeInvalido(maquina));
     }
@@ -896,7 +908,7 @@ function entrarNaRede(opcoes = {}) {
 function sairDaRede(opcoes = {}) {
     // U3 da revisao 3: a saida local vem primeiro; nada depois dela pode deixar a maquina membro.
     (0, rede_adesao_1.gravarConfigDaRede)({ membro: false });
-    const maquina = nomeSeguro((0, maquina_1.nomeDaMaquina)(opcoes.maquina));
+    const maquina = nomeGenericoDaRede(opcoes.maquina);
     const r = resolverCasa(opcoes);
     if (r.casa)
         (0, rede_adesao_1.gravarConfigDaRede)({ forja: r.casa.forja, host: r.casa.host, dono: r.casa.dono, repositorio: r.casa.repositorio });

package/dist/retry.js

@@ -288,6 +288,12 @@ exports.POLITICA_DE_RETRY = {
         automatica: true,
         ...TEXTOS_DA_POLITICA['lease.busy'],
     },
+    'concurrency.lease-indeterminado': {
+        motivo: 'concurrency.lease-indeterminado',
+        acao: 'esperar-janela',
+        automatica: false,
+        ...TEXTOS_DA_POLITICA['concurrency.lease-indeterminado'],
+    },
     // 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': {
@@ -296,6 +302,12 @@ exports.POLITICA_DE_RETRY = {
         automatica: true,
         ...TEXTOS_DA_POLITICA['conducao.em-andamento'],
     },
+    'conducao.acao-necessaria': {
+        motivo: 'conducao.acao-necessaria',
+        acao: 'esperar-janela',
+        automatica: false,
+        ...TEXTOS_DA_POLITICA['conducao.acao-necessaria'],
+    },
     // 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': {

package/dist/sandbox.js

@@ -1,15 +1,15 @@
 "use strict";
 /**
- * Sandbox deterministica para os canarios de `ork eval` (bloco B4).
+ * Sandbox deterministica para os cenarios de `ork eval` (bloco B4).
  *
- * Um canario precisa exercitar o comportamento REAL do nucleo: git de verdade, worktree de
+ * Um cenario precisa exercitar o comportamento REAL do nucleo: git de verdade, worktree de
  * verdade, lease de verdade. Fazer isso no repositorio do usuario seria inaceitavel, e
  * simular git com dublê seria testar o dublê. A saida e um repositorio git temporario,
  * criado, usado e apagado dentro da mesma execucao.
  *
  * Regras que esta sandbox respeita, e por isso ela pode rodar em `ork eval` na maquina de
  * qualquer builder: nada de rede, nada de credencial, nada fora de um diretorio temporario,
- * e limpeza garantida mesmo quando o canario falha.
+ * e limpeza garantida mesmo quando o cenario falha.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -55,7 +55,7 @@ const path = __importStar(require("node:path"));
 const init_1 = require("./init");
 const manifest_1 = require("./manifest");
 const util_1 = require("./util");
-/** `git` existe nesta maquina? Sem ele os canarios saem `unavailable`, nunca `passing`. */
+/** `git` existe nesta maquina? Sem ele os cenarios saem `unavailable`, nunca `passing`. */
 function gitDisponivel() {
     return (0, util_1.noPath)('git') !== null;
 }
@@ -75,15 +75,15 @@ function commitar(dir, arquivo, conteudo, mensagem) {
 /**
  * Repositorio git temporario com manifesto gerado pelo proprio `ork init`.
  *
- * O manifesto vem do `init` de verdade e nao de um objeto escrito a mao: canario que monta o
- * proprio manifesto testa o canario, nao o produto.
+ * O manifesto vem do `init` de verdade e nao de um objeto escrito a mao: cenario que monta o
+ * proprio manifesto testa o cenario, nao o produto.
  */
 function sandboxGit(nome, abbrev = 'evl') {
-    // I-49: canario nunca escreve no registro compartilhado de contas do usuario.
+    // I-49: cenario nunca escreve no registro compartilhado de contas do usuario.
     if (!process.env.ORK_CONTAS_DIR) {
         process.env.ORK_CONTAS_DIR = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'ork-contas-eval-')), 'private');
     }
-    // I-51: canario nunca publica o estado da fabrica.
+    // I-51: cenario nunca publica o estado da fabrica.
     if (process.env.ORK_FABRICA_PUBLICAR === undefined)
         process.env.ORK_FABRICA_PUBLICAR = '0';
     if (!process.env.ORK_USUARIO_DIR)
@@ -91,10 +91,10 @@ function sandboxGit(nome, abbrev = 'evl') {
     const dir = dirTemporario(nome);
     (0, util_1.exec)('git', ['init', '-b', 'main'], dir);
     (0, util_1.exec)('git', ['config', 'user.email', 'eval@orkastery.local'], dir);
-    (0, util_1.exec)('git', ['config', 'user.name', 'Canario do ork eval'], dir);
+    (0, util_1.exec)('git', ['config', 'user.name', 'Cenario do ork eval'], dir);
     (0, util_1.exec)('git', ['config', 'commit.gpgsign', 'false'], dir);
-    commitar(dir, 'README.md', '# projeto do canario\n', 'inicial');
-    (0, init_1.init)(dir, { nome: 'canario', abbrev });
+    commitar(dir, 'README.md', '# projeto do cenario\n', 'inicial');
+    (0, init_1.init)(dir, { nome: 'cenario', abbrev });
     return {
         dir,
         carregado: (0, manifest_1.exigirManifesto)(dir),

package/dist/security-scan/cli.js

@@ -55,7 +55,7 @@ function executarSecurityScan(argv, ctx) {
         const message = e.message;
         if (!/^security-scan\.(config-invalid|dismissal-invalid)/.test(message))
             throw e;
-        console.error(message);
+        console.error(json ? message : m.error(message));
         return 1;
     }
     const files = (0, report_1.writeReport)(ctx.estado, report);
@@ -68,7 +68,7 @@ function executarSecurityScan(argv, ctx) {
         if (notRun.length) {
             ctx.escrever(m.notRunHeading);
             for (const r of notRun)
-                ctx.escrever(m.notRun(r.name, m.states[r.state] ?? r.state, r.reason ?? ''));
+                ctx.escrever(m.notRun(r.name, m.states[r.state] ?? r.state, m.reason(r.reason ?? '')));
         }
         ctx.escrever(files.md);
     }

package/dist/security-scan/report.js

@@ -143,7 +143,7 @@ function renderMarkdown(report) {
     else {
         out.push(`| ${m.tableTool} | ${m.tableExecutor} | ${m.tableState} | ${m.tableReason} |`, '| --- | --- | --- | --- |');
         for (const r of report.tools) {
-            out.push(`| ${cell(r.name)} | ${r.executor ?? m.noExecutor} | ${m.states[r.state] ?? r.state} | ${cell(r.reason ?? '')} |`);
+            out.push(`| ${cell(r.name)} | ${r.executor ?? m.noExecutor} | ${m.states[r.state] ?? r.state} | ${cell(m.reason(r.reason ?? ''))} |`);
         }
     }
     const news = report.findings.filter(f => f.status === 'new');

package/dist/session-watcher.js

@@ -61,6 +61,17 @@ const session_watcher_claude_1 = require("./session-watcher-claude");
 const session_watcher_grok_1 = require("./session-watcher-grok");
 const conta_esgotada_1 = require("./conta-esgotada");
 const trabalho_thread_1 = require("./trabalho-thread");
+const pedido_conducao_1 = require("./pedido-conducao");
+/** O gate estreito da própria sessão vence diagnósticos genéricos do watcher. */
+function pedidoDaConducao(eventos, sessionId, despachoEm) {
+    const evento = eventos.filter(e => e.tipo === 'gate_blocked' && e.origem === 'mcp.request_conduction' &&
+        e.sessionId === sessionId && e.despachoEm === despachoEm && typeof e.motivo === 'string' &&
+        pedido_conducao_1.MOTIVOS_DE_PEDIDO_A_CONDUCAO.includes(e.motivo) &&
+        typeof e.comando === 'string' && typeof e.despacho === 'string').at(-1);
+    return evento ? { motivo: evento.motivo, comando: evento.comando,
+        detalhe: typeof evento.detalhe === 'string' ? evento.detalhe : 'sessão solicitou ação da condução',
+        despacho: evento.despacho } : null;
+}
 /** Falhas operacionais e bloqueios sem retry automático não alegam conclusão do produto. */
 function bloqueioPreservado(terminal) {
     return terminal.classificacao === 'gate_blocked' && terminal.motivo !== null &&
@@ -474,18 +485,25 @@ function reconciliarSessaoSemWatcher(carregado, threadId, agoraMs = Date.now())
             if (atuais.some(e => e.tipo === 'phase_result' && e.sessionId === sessao.sessionId &&
                 e.despachoEm === sessao.despachadaEm))
                 return;
+            const pedido = pedidoDaConducao(atuais, sessao.sessionId, sessao.despachadaEm);
             const dados = { fase: sessao.fase, sessionId: sessao.sessionId, despachoEm: sessao.despachadaEm,
-                sensorResultId, classificacao: 'gate_blocked', motivo: 'runtime.unavailable', runtime: sessao.runtime,
-                fonte: 'conducao.batida: sessão verificada sem watcher e sem evento útil', fonteVencedora: null,
+                sensorResultId, classificacao: 'gate_blocked', motivo: pedido?.motivo ?? 'runtime.unavailable', runtime: sessao.runtime,
+                fonte: pedido ? 'mcp.request_conduction: parada intencional tipada pela sessão'
+                    : 'conducao.batida: sessão verificada sem watcher e sem evento útil', fonteVencedora: null,
                 ok: false, conclusaoNativa: false, conclusaoNativaAusente: 'watcher ausente e fonte indisponível além do limite',
                 estado: 'bloqueada', observadoEm: new Date(agoraMs).toISOString(), gate: 'phase.dispatch',
-                origem: 'conducao.batida', morteLatenciaMs: agoraMs - ultimoUtil };
-            (0, ledger_1.registrar)(dir, threadId, 'sessao_morta', dados);
+                origem: 'conducao.batida', morteLatenciaMs: agoraMs - ultimoUtil,
+                ...(pedido ? { detalhe: pedido.detalhe, correcao: pedido.comando, comando: pedido.comando,
+                    pedidoConducao: { contrato: 'ork.pedido-conducao/v1', despacho: pedido.despacho, estado: 'aberto' } } : {}) };
+            if (!pedido)
+                (0, ledger_1.registrar)(dir, threadId, 'sessao_morta', dados);
             (0, ledger_1.registrar)(dir, threadId, 'gate_blocked', dados);
             (0, ledger_1.registrar)(dir, threadId, 'phase_result', dados);
         });
         return { thread: threadId, sessionId: sessao.sessionId, estado: 'parada',
-            detalhe: 'sessão verificada sem watcher e sem evento útil além do limite' };
+            detalhe: pedidoDaConducao((0, ledger_1.lerLedger)(dir), sessao.sessionId, sessao.despachadaEm)
+                ? 'sessão parou com pedido tipado para a condução'
+                : 'sessão verificada sem watcher e sem evento útil além do limite' };
     }
 }
 function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registrada }, opcoes) {
@@ -714,6 +732,7 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                 }
                 if (!podeTerminar)
                     return { ...base, bytesLidos };
+                const pedido = pedidoDaConducao(atuais, sessionId, sessao.despachadaEm);
                 const semTerminal = !terminal;
                 // Fato registrado para a autoridade de revisão: `null` só com terminal nativo correlacionado.
                 const conclusaoNativa = incompleto || invalido || aberto || descorrelacionado
@@ -726,6 +745,11 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     terminal = { classificacao: 'gate_blocked', motivo: 'runtime.silencio',
                         timestamp: new Date(now).toISOString(), turnId: null, fonte: 'processo ausente e arquivos estáveis',
                         tokens: new codex_events_1.ParserCodex().estado.tokens, duracaoMs: null };
+                if (pedido && (terminal.classificacao === 'fase_concluida' ||
+                    terminal.classificacao === 'gate_blocked' && ['runtime.unavailable', 'runtime.silencio'].includes(terminal.motivo ?? ''))) {
+                    terminal = { ...terminal, classificacao: 'gate_blocked', motivo: pedido.motivo,
+                        fonte: `mcp.request_conduction: ${pedido.detalhe}` };
+                }
                 if (fechamento && (fechamento.exitCode !== 0 || fechamento.signal || fechamento.erro) &&
                     terminal.classificacao !== 'human.pending' && !bloqueioPreservado(terminal)) {
                     terminal = { ...terminal, classificacao: 'gate_blocked', motivo: 'runtime.unavailable' };
@@ -739,7 +763,7 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     ? (0, trabalho_thread_1.gravarRespostaFinalDaSessao)(carregado.raiz, thread.id, sessionId, terminal.respostaFinal) : null;
                 const dados = { fase: sessao.fase, sessionId, despachoEm: sessao.despachadaEm, sensorResultId: resultadoId,
                     classificacao: terminal.classificacao, motivo: terminal.motivo, runtime: 'codex', fonte: terminal.fonte,
-                    fonteVencedora: incompleto || invalido || aberto || descorrelacionado ? null : terminais[0]?.nome ?? null,
+                    fonteVencedora: pedido || incompleto || invalido || aberto || descorrelacionado ? null : terminais[0]?.nome ?? null,
                     turnId: terminal.turnId, numeroTurno: terminal.numeroTurno ?? null,
                     tokens: terminal.tokens, exitCode: fechamento?.exitCode ?? null, exitCodeFonte: fechamento?.fonte ?? 'unavailable',
                     signal: fechamento?.signal ?? null, duracaoMs: fechamento?.duracaoMs ?? terminal.duracaoMs,
@@ -750,11 +774,13 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     estado: terminal.classificacao === 'fase_concluida' ? 'concluida' : 'bloqueada',
                     observadoEm: terminal.timestamp, gate: 'phase.dispatch', origem: 'sessions.watch',
                     morteLatenciaMs: morte ? now - cursor.progressoEm : null, ...(perfil ? { perfil } : {}),
+                    ...(pedido ? { detalhe: pedido.detalhe, correcao: pedido.comando, comando: pedido.comando,
+                        pedidoConducao: { contrato: 'ork.pedido-conducao/v1', despacho: pedido.despacho, estado: 'aberto' } } : {}),
                     ...(respostaFinal ? { respostaFinal: { arquivo: (0, trabalho_thread_1.caminhoDoTrabalho)(thread.id) + respostaFinal.arquivo,
                             sha256: respostaFinal.sha256, bytes: respostaFinal.bytes, truncada: respostaFinal.truncada } } : {}),
                     ...(conta ? { falhaDeConta: { motivo: conta.falha.motivo, resetEm: conta.falha.resetEm, fonte: conta.falha.fonte,
                             trecho: conta.falha.trecho } } : {}) };
-                const tipo = semTerminal && morte && !incompleto && !conta ? 'sessao_morta' : terminal.classificacao;
+                const tipo = semTerminal && morte && !incompleto && !conta && !pedido ? 'sessao_morta' : terminal.classificacao;
                 // I-33 (D12): o perfil sai do rodizio na primeira gravacao do resultado, onde a evidencia esta.
                 if (conta && perfil && !atuais.some(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId)) {
                     try {