@orkastery/cli 0.5.1 → 0.5.6

package/dist/hitl-contract.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTRATOS_DE_PEDIDO = exports.CAMPOS_DA_DECISAO_NO_MCP = exports.CAMPOS_DA_DECISAO_NO_CLI = exports.CAMPOS_DE_GATE = exports.TETOS_HITL_V2 = exports.LETRAS_DE_ALTERNATIVA = exports.CONTRATO_HITL_V2 = exports.ATO_IRREVERSIVEL_DO_MOTIVO = exports.ATOS_IRREVERSIVEIS = exports.CONTRATO_HITL = void 0;
+exports.CONTRATOS_DE_PEDIDO = exports.SelecaoRecusada = exports.MAXIMO_DE_ALTERNATIVAS_DE_CONDUCAO = exports.MINIMO_DE_ALTERNATIVAS_DE_CONDUCAO = exports.CAMPOS_DA_DECISAO_NO_MCP = exports.CAMPOS_DA_DECISAO_NO_CLI = exports.CAMPOS_DE_GATE = exports.TETOS_HITL_V2 = exports.LETRAS_DE_ALTERNATIVA = exports.CONTRATO_HITL_V2 = exports.ATO_IRREVERSIVEL_DO_MOTIVO = exports.ATOS_IRREVERSIVEIS = exports.CONTRATO_HITL = void 0;
 exports.atoDaPausa = atoDaPausa;
 exports.profundidadeDoModo = profundidadeDoModo;
 exports.profundidadeDoPedido = profundidadeDoPedido;
@@ -10,6 +10,7 @@ exports.respostaAceitaDoPedido = respostaAceitaDoPedido;
 exports.validarRespostaHitl = validarRespostaHitl;
 exports.vereditoDoGate = vereditoDoGate;
 exports.recusaNaSuperficie = recusaNaSuperficie;
+exports.exigirSelecaoDeConducao = exigirSelecaoDeConducao;
 exports.validarPedidoHitlV2 = validarPedidoHitlV2;
 exports.validarPedidoHitl = validarPedidoHitl;
 exports.ehV2 = ehV2;
@@ -201,7 +202,8 @@ function vereditoDoGate(pedido, opcao) {
 //   `pergunta` e o unico que pode segurar, e o unico que o dono precisa responder.
 // ---------------------------------------------------------------------------
 exports.CONTRATO_HITL_V2 = 'ork.hitl/v2';
-exports.LETRAS_DE_ALTERNATIVA = ['a', 'b', 'c', 'd'];
+/** RM-057: ate cinco alternativas, de a a e. A leitura aceita as de duas do historico. */
+exports.LETRAS_DE_ALTERNATIVA = ['a', 'b', 'c', 'd', 'e'];
 /** D13: tetos com origem na maior medida ja gravada nos catorze pedidos do historico. */
 exports.TETOS_HITL_V2 = Object.freeze({
     pergunta: 200, alternativaTexto: 140, consequencia: 140, porque: 140,
@@ -284,12 +286,12 @@ function validarDecidido(v) {
 function validarAlternativas(v) {
     const alternativas = v.alternativas;
     if (!Array.isArray(alternativas) || alternativas.length < 2 || alternativas.length > exports.LETRAS_DE_ALTERNATIVA.length) {
-        throw new Error('pedido HITL v2: de 2 a 4 alternativas, rotuladas de a a d');
+        throw new Error('pedido HITL v2: de 2 a 5 alternativas, rotuladas de a a e');
     }
     let recomendadas = 0;
     alternativas.forEach((bruta, i) => {
         if (!objeto(bruta) || bruta.letra !== exports.LETRAS_DE_ALTERNATIVA[i]) {
-            throw new Error('pedido HITL v2: de 2 a 4 alternativas, rotuladas de a a d');
+            throw new Error('pedido HITL v2: de 2 a 5 alternativas, rotuladas de a a e');
         }
         if (!linhaUnica(bruta.texto, exports.TETOS_HITL_V2.alternativaTexto))
             throw new Error('pedido HITL v2: alternativa sem texto');
@@ -343,6 +345,12 @@ function validarPergunta(v) {
         !['esperar', 'escalar', 'seguir-recomendada'].includes(v.acaoPadraoAoExpirar)) {
         throw new Error('pedido HITL v2: prazo ou ação de expiração inválidos');
     }
+    if (v.dependenciaTecnica !== undefined) {
+        const d = v.dependenciaTecnica;
+        if (!objeto(d) || !linhaUnica(d.comando, exports.TETOS_HITL_V2.campoDaDecisao) || !linhaUnica(d.porque, exports.TETOS_HITL_V2.porque)) {
+            throw new Error('pedido HITL v2: dependência técnica exige o comando exato e o porquê, uma linha cada');
+        }
+    }
     if (typeof v.irreversivel !== 'boolean')
         throw new Error('pedido HITL v2: irreversível precisa ser declarado');
     if (v.irreversivel) {
@@ -358,6 +366,53 @@ function validarPergunta(v) {
         throw new Error('pedido HITL v2: só pedido irreversível nomeia ato');
     }
 }
+// ---------------------------------------------------------------------------
+// RM-057: o HITL de conducao que parte do ork e uma SELECAO.
+//
+// Na noite de 01 para 02/10/2026 a conducao parou mais de dez horas esperando um "confirmo" em
+// texto livre. A regra do dono (02/10) e que todo pedido que o PROPRIO ork abre ao maestro sai com
+// de 3 a 5 alternativas, exatamente uma com o selo "Recomendação", e nunca depende de o dono
+// escrever ou colar texto. A unica excecao e a dependencia tecnica tipada: o dono roda um comando
+// no terminal que a fabrica nao consegue rodar sozinha.
+//
+// A regra vale na CRIACAO (`registrarPedidoHitl`), nunca na leitura: o ledger guarda pedidos de
+// duas alternativas que continuam legiveis para sempre, e a pergunta nativa de uma sessao do host
+// (v1) traz as opcoes do host, que nao sao do ork.
+// ---------------------------------------------------------------------------
+exports.MINIMO_DE_ALTERNATIVAS_DE_CONDUCAO = 3;
+exports.MAXIMO_DE_ALTERNATIVAS_DE_CONDUCAO = 5;
+class SelecaoRecusada extends Error {
+    motivo;
+    constructor(motivo, detalhe) {
+        super(`${motivo}: ${detalhe}`);
+        this.motivo = motivo;
+        this.name = 'SelecaoRecusada';
+    }
+}
+exports.SelecaoRecusada = SelecaoRecusada;
+/**
+ * RM-057: confere que um pedido que o ork vai ABRIR e uma selecao. Decisao informada (`decidido`)
+ * nao pergunta nada e passa. Recusa com motivo tipado, nunca corta nem completa em silencio.
+ */
+function exigirSelecaoDeConducao(pedido) {
+    if (!ehV2(pedido)) {
+        throw new SelecaoRecusada('hitl.selecao.versao', 'o pedido de condução do ork sai em ork.hitl/v2, com alternativas declaradas');
+    }
+    if (pedido.classe === 'decidido')
+        return;
+    const n = pedido.alternativas.length;
+    if (n < exports.MINIMO_DE_ALTERNATIVAS_DE_CONDUCAO || n > exports.MAXIMO_DE_ALTERNATIVAS_DE_CONDUCAO) {
+        throw new SelecaoRecusada('hitl.selecao.fora-da-faixa', `de ${exports.MINIMO_DE_ALTERNATIVAS_DE_CONDUCAO} a ${exports.MAXIMO_DE_ALTERNATIVAS_DE_CONDUCAO} alternativas, este traz ${n}`);
+    }
+    const recomendadas = pedido.alternativas.filter(a => a.recomendada).length;
+    if (recomendadas !== 1) {
+        throw new SelecaoRecusada('hitl.selecao.recomendada', `exatamente uma alternativa com o selo Recomendação, este traz ${recomendadas}`);
+    }
+    const pedeTexto = pedido.tipoDeResposta === 'aberta' || pedido.respostaAceita.tipo === 'texto';
+    if (pedeTexto && !pedido.dependenciaTecnica) {
+        throw new SelecaoRecusada('hitl.selecao.texto-livre', 'resposta em texto só com dependência técnica tipada: o comando exato que o dono roda no terminal e o porquê');
+    }
+}
 /** Valida `ork.hitl/v2`. Nunca aceita um v1: quem julga v1 e o validador congelado. */
 function validarPedidoHitlV2(v) {
     if (!objeto(v) || v.contrato !== exports.CONTRATO_HITL_V2)

package/dist/hitl-curto.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TEXTO_DO_ATO = exports.TETO_DE_LINHAS_DO_CORPO = exports.TETO_DE_LINHAS_DO_PEDIDO = exports.CONTRATO_PEDIDO_CURTO = void 0;
+exports.TEXTO_DO_ATO = exports.TETO_DE_LINHAS_DO_CORPO = exports.TETO_DE_LINHAS_DO_PEDIDO = exports.SELO_DA_RECOMENDADA = exports.CONTRATO_PEDIDO_CURTO = void 0;
 exports.entradaDoPedido = entradaDoPedido;
 exports.montarPedidoCurto = montarPedidoCurto;
 exports.linhaDeResposta = linhaDeResposta;
@@ -23,7 +23,8 @@ exports.desdeDoPedido = desdeDoPedido;
  *   trava        o que esta parado, desde quando, e o que acontece sem resposta;
  *   sem volta    so quando responder autoriza um ato da lista congelada;
  *   corpo        no maximo `TETO_DE_LINHAS_DO_CORPO` linhas de evidencia;
- *   alternativas de 2 a 4, uma linha cada, com a consequencia, e UMA recomendada com o porque;
+ *   alternativas de 2 a 5, uma linha cada, com a consequencia, e UMA com o selo "Recomendação" e o
+ *                porque (RM-057: o pedido que o proprio ork abre traz de 3 a 5);
  *   responder    a ultima linha, dizendo exatamente o que digitar.
  *
  * O detalhe profundo (artefato, claims, riscos, diff) fica a um pedido de distancia: a ultima
@@ -36,6 +37,8 @@ const hitl_1 = require("./hitl");
 const hitl_contract_1 = require("./hitl-contract");
 const horario_1 = require("./horario");
 exports.CONTRATO_PEDIDO_CURTO = 'ork.hitl-curto/v1';
+/** RM-057: o selo que o dono procura na lista, igual em todo canal. */
+exports.SELO_DA_RECOMENDADA = 'Recomendação';
 /** Nenhum pedido passa disto por padrao (RM-048, criterio c). */
 exports.TETO_DE_LINHAS_DO_PEDIDO = 15;
 /** Evidencia que cabe na pergunta curta; o resto vai no detalhe. */
@@ -80,11 +83,11 @@ function semResposta(e, agora) {
 }
 /**
  * Monta o pedido curto. Recusa, em vez de cortar em silencio, o que o contrato nao aceita: menos
- * de duas alternativas, mais de quatro, ou recomendada diferente de exatamente uma.
+ * de duas alternativas, mais de cinco, ou recomendada diferente de exatamente uma.
  */
 function montarPedidoCurto(e, opcoes) {
-    if (e.alternativas.length < 2 || e.alternativas.length > 4)
-        throw new Error('pedido curto: de 2 a 4 alternativas');
+    if (e.alternativas.length < 2 || e.alternativas.length > 5)
+        throw new Error('pedido curto: de 2 a 5 alternativas');
     if (e.alternativas.filter(a => a.recomendada).length !== 1)
         throw new Error('pedido curto: exatamente uma alternativa é recomendada');
     const onde = e.alvo?.tipo === 'session'
@@ -110,6 +113,8 @@ function linhaDeResposta(p, canal) {
         return null;
     if (r.tipo === 'texto')
         return `${canal === 'telegram' ? '↩️ ' : ''}Responda escrevendo o texto; ele é enviado como está.`;
+    if (r.tipo === 'terminal')
+        return `${canal === 'telegram' ? '↩️ ' : 'Responder: '}feito o comando, ${recomendada}) é \`${r.comando}\`.`;
     if (r.tipo === 'dialogo')
         return `${canal === 'telegram' ? '↩️ ' : ''}Responda selecionando a opção no diálogo; digitar a letra também vale.`;
     return canal === 'telegram'
@@ -132,7 +137,7 @@ function textoDoPedidoCurto(p, canal) {
         ...(p.semVolta ? [`${tg ? '🔒 ' : '! '}${p.semVolta}`] : []),
         ...p.corpo.map(l => `${tg ? '• ' : '- '}${l}`),
         ...p.alternativas.flatMap(a => [
-            `${a.chave}) ${a.texto}${a.recomendada ? (tg ? ' ✅ recomendada' : ' [recomendada]') : ''}: ${a.consequencia}`,
+            `${a.chave}) ${a.texto}${a.recomendada ? (tg ? ` ✅ ${exports.SELO_DA_RECOMENDADA}` : ` [${exports.SELO_DA_RECOMENDADA}]`) : ''}: ${a.consequencia}`,
             ...(a.recomendada ? [`   porquê: ${a.recomendada.porque}`] : []),
         ]),
     ];

package/dist/hitl-gates.js

@@ -215,6 +215,11 @@ function resolverCriterio(raiz, pedido) {
 }
 function registrarPedidoHitl(raiz, pedido) {
     (0, hitl_contract_1.validarPedidoHitl)(pedido);
+    // RM-057: o pedido que o ork abre ao dono e uma selecao de 3 a 5, com uma recomendada. O v1 e o
+    // contrato congelado que o nucleo nao emite mais por aqui (o gate sai em v2 desde a I-41); ele
+    // segue registravel so para os leitores do historico e para os testes que o reproduzem.
+    if ((0, hitl_contract_1.ehV2)(pedido))
+        (0, hitl_contract_1.exigirSelecaoDeConducao)(pedido);
     // R1, camada 1: um `decidido` cujo critério não resolve não chega a existir.
     if ((0, hitl_contract_1.ehV2)(pedido) && pedido.classe === 'decidido') {
         const { resolve, detalhe } = resolverCriterio(raiz, pedido);

package/dist/hitl-local-receipt.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.chaveLocal = chaveLocal;
 exports.gravarEvidenciaLocal = gravarEvidenciaLocal;
 exports.gravarEvidenciaLocalSessao = gravarEvidenciaLocalSessao;
 exports.validarEvidenciaLocalSessao = validarEvidenciaLocalSessao;
@@ -70,6 +71,7 @@ function diretorioPrivado(file) {
     }
     return validarDiretorio(file, 0o700);
 }
+/** RM-058 (N1): exportada só para o arco #Noctum derivar a subchave dele (`noctum-arco.ts`). */
 function chaveLocal(raiz, criar) {
     const estado = path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery');
     const stEstado = fs.lstatSync(estado);

package/dist/hitl-lote.js

@@ -34,8 +34,11 @@ const hitl_curto_1 = require("./hitl-curto");
 exports.CONTRATO_LOTE = 'ork.hitl-lote/v1';
 /** De cinco em cinco, como o dono pediu. As que sobram continuam guardadas, nao somem. */
 exports.TETO_DE_PERGUNTAS_POR_LOTE = 5;
-/** De 2 a 4 alternativas, rotuladas em sequencia. Cinco nao cabem numa escolha rapida. */
-exports.LETRAS = ['a', 'b', 'c', 'd'];
+/**
+ * De 2 a 5 alternativas, rotuladas em sequencia. RM-057: o pedido de conducao do ork traz de 3 a 5;
+ * o lote ainda le as de 2 do historico e as perguntas nativas das sessoes.
+ */
+exports.LETRAS = ['a', 'b', 'c', 'd', 'e'];
 /**
  * O que acontece ao escolher, por acao. Mapa TOTAL sobre as acoes do pedido: acao nova quebra o
  * build aqui, que e o comportamento desejado. Uma alternativa sem consequencia dita e uma

package/dist/hitl-resumo.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEM_PERGUNTA_NO_RESUMO = exports.TETO_DE_DECISOES_DETALHADAS = exports.TETO_DE_ESPERAS_POR_MAQUINA = exports.TETO_DE_PARADOS_NO_CONDUTOR = exports.TETO_DE_THREADS_NOMEADAS = exports.PERGUNTA_DO_RESUMO = exports.CONTRATO_RESUMO = void 0;
+exports.SEM_PERGUNTA_COM_IMPEDIMENTO = exports.SEM_PERGUNTA_NO_RESUMO = exports.TETO_DE_DECISOES_DETALHADAS = exports.TETO_DE_ESPERAS_POR_MAQUINA = exports.TETO_DE_IMPEDIMENTOS = exports.TETO_DE_PARADOS_NO_CONDUTOR = exports.TETO_DE_THREADS_NOMEADAS = exports.PERGUNTA_DO_RESUMO = exports.CONTRATO_RESUMO = void 0;
 exports.resumirHitl = resumirHitl;
 exports.linhaDoParadoNoCondutor = linhaDoParadoNoCondutor;
 exports.linhasDoCondutor = linhasDoCondutor;
+exports.linhasDosImpedimentos = linhasDosImpedimentos;
 exports.linhaDosTecnicos = linhaDosTecnicos;
 exports.linhasDasOutrasMaquinas = linhasDasOutrasMaquinas;
 exports.linhasDasDecisoes = linhasDasDecisoes;
@@ -29,6 +30,8 @@ exports.textoDoResumo = textoDoResumo;
  * mensagem do canal. Quem entrega chama a segunda.
  */
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
+const hitl_tempo_parado_1 = require("./hitl-tempo-parado");
 const decisao_autonoma_1 = require("./decisao-autonoma");
 const hitl_classificacao_1 = require("./hitl-classificacao");
 exports.CONTRATO_RESUMO = 'ork.hitl-resumo/v1';
@@ -59,6 +62,9 @@ function resumirHitl(itens, opcoes) {
         threadsTecnicas: [...new Set(tecnicos.map(i => i.thread).filter((t) => !!t))].sort(),
         ...(opcoes.paradosNoCondutor?.length ? { paradosNoCondutor: opcoes.paradosNoCondutor.map(p => ({ thread: p.thread, caso: p.caso,
                 desdeEm: p.desdeEm, proximoPasso: p.proximoPasso })) } : {}),
+        ...(opcoes.impedimentosDoDono?.length ? { impedimentosDoDono: opcoes.impedimentosDoDono.map(i => ({ thread: i.thread,
+                fase: i.fase, comando: i.comando, retry: i.retry })) } : {}),
+        ...(opcoes.hitlDeConducao?.acimaDaMeta ? { hitlDeConducao: opcoes.hitlDeConducao } : {}),
     };
 }
 /** Quantas linhas do condutor o resumo mostra antes de contar o resto. */
@@ -69,7 +75,7 @@ exports.TETO_DE_PARADOS_NO_CONDUTOR = 5;
  */
 function linhaDoParadoNoCondutor(p, opcoes) {
     const { desdeEm: desde } = p;
-    return `${p.thread} parado no condutor desde ${(0, horario_1.formatarHora)(desde, opcoes)}: ${p.proximoPasso}`;
+    return (0, locale_1.msg)().pulse.linhaDoCondutor(p.thread, (0, horario_1.formatarHora)(desde, opcoes), p.proximoPasso);
 }
 /** As linhas do condutor no resumo, uma por thread, com o resto contado. */
 function linhasDoCondutor(r, marcador, recuo) {
@@ -78,6 +84,29 @@ function linhasDoCondutor(r, marcador, recuo) {
     return [...mostradas.map(p => `${marcador}${linhaDoParadoNoCondutor(p, { agora: r.consultadoEm })}`),
         ...(sobra > 0 ? [`${recuo}e mais ${sobra}: ork pulse`] : [])];
 }
+/** Quantos impedimentos do dono o resumo detalha antes de contar o resto. */
+exports.TETO_DE_IMPEDIMENTOS = 5;
+/** Uma linha so, sem caractere de controle e sem corte: o comando precisa chegar inteiro para ser copiado. */
+const semQuebra = (texto) => String(texto).replace(/\p{Cc}/gu, ' ').replace(/\s+/g, ' ').trim();
+/**
+ * RM-055 (continuacao, D3): o titulo e uma linha por impedimento do dono, iguais nos dois canais (so o
+ * marcador e o recuo mudam). Cada linha diz a thread, a fase, o comando exato e o retry que vem depois.
+ */
+function linhasDosImpedimentos(r, marcador, recuo) {
+    const impedimentos = r.impedimentosDoDono ?? [];
+    if (!impedimentos.length)
+        return [];
+    const mostrados = impedimentos.slice(0, exports.TETO_DE_IMPEDIMENTOS), sobra = impedimentos.length - mostrados.length;
+    return [`${marcador}Só você destrava, no terminal: ${impedimentos.length}`,
+        ...mostrados.map(i => `${recuo}• ${semQuebra(i.thread)}${i.fase ? ` ${semQuebra(i.fase)}` : ''}: ` +
+            `rode \`${semQuebra(i.comando)}\`; depois \`${semQuebra(i.retry)}\``),
+        ...(sobra > 0 ? [`${recuo}e mais ${sobra}: ork pulse`] : [])];
+}
+/** RM-057 (fatia 3): a linha do tempo parado por HITL de conducao, a mesma nos dois canais. */
+function linhaDoHitlParado(r) {
+    const linha = (0, hitl_tempo_parado_1.linhaDoHitlAcimaDaMeta)(r.hitlDeConducao, { agora: r.consultadoEm });
+    return linha ? [linha] : [];
+}
 /** RM-048 (D6): a linha do que e tecnico, igual nos dois canais. Nao pede nada ao dono. */
 function linhaDosTecnicos(r) {
     const nomes = r.threadsTecnicas.length ? ` (${nomearThreads(r.threadsTecnicas)})` : '';
@@ -136,6 +165,8 @@ function linhasDasDecisoes(r, marcador, recuo) {
 }
 /** Quando nao ha pergunta, o resumo diz isso em vez de pedir licenca para mandar nada. */
 exports.SEM_PERGUNTA_NO_RESUMO = 'Nada aqui pede resposta sua por este canal agora.';
+/** RM-055 (continuacao, D3): sem pergunta, mas com impedimento do dono: o que fazer esta no bloco acima. */
+exports.SEM_PERGUNTA_COM_IMPEDIMENTO = 'Nada aqui pede resposta sua por este canal agora; o que só você destrava está acima, no terminal.';
 /** A linha das perguntas prontas, uma so para os dois canais, pelo mesmo motivo da de baixo. */
 function linhaDasPerguntas(n) {
     return `Perguntas para você: ${n}`;
@@ -185,7 +216,7 @@ function abertura(r, codigo, marca, resposta) {
     return r.pergunta ? [`${marca}${r.pergunta}`, ...linhaDeResposta(codigo).map(l => `${resposta}${l}`), ''] : [];
 }
 function fecho(r) {
-    return r.pergunta ? [] : ['', exports.SEM_PERGUNTA_NO_RESUMO];
+    return r.pergunta ? [] : ['', r.impedimentosDoDono?.length ? exports.SEM_PERGUNTA_COM_IMPEDIMENTO : exports.SEM_PERGUNTA_NO_RESUMO];
 }
 function textoTelegram(r, codigo) {
     const quando = (0, horario_1.formatarDataHoraRotulada)(r.consultadoEm, { agora: r.consultadoEm });
@@ -201,6 +232,8 @@ function textoTelegram(r, codigo) {
         `❓ ${linhaDasPerguntas(r.prontas)}`,
         ...(r.tecnicos ? [`🔧 ${linhaDosTecnicos(r)}`] : []),
         ...(r.consertos ? [`🔧 ${linhaDosConsertos(r.consertos)}`] : []),
+        ...linhaDoHitlParado(r).map(l => `⏳ ${l}`),
+        ...(r.impedimentosDoDono?.length ? ['', ...linhasDosImpedimentos(r, '🔑 ', '   ')] : []),
         ...(r.paradosNoCondutor?.length ? ['', ...linhasDoCondutor(r, '🚧 ', '   ')] : []),
         ...(r.acumuladas ? ['', `📥 ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
         ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '🧭 ', '   ')] : []),
@@ -232,6 +265,8 @@ function textoTerminal(r, codigo) {
             ? ['', `  threads travadas (${r.threadsBloqueadas.length}): ${nomearThreads(r.threadsBloqueadas)}`] : []),
         ...(r.tecnicos ? ['', `  ${linhaDosTecnicos(r)}`] : []),
         ...(r.consertos ? ['', `  ${linhaDosConsertos(r.consertos)}`] : []),
+        ...linhaDoHitlParado(r).flatMap(l => ['', `  ${l}`]),
+        ...(r.impedimentosDoDono?.length ? ['', ...linhasDosImpedimentos(r, '  ', '  ')] : []),
         ...(r.paradosNoCondutor?.length ? ['', ...linhasDoCondutor(r, '  ', '  ')] : []),
         ...(r.acumuladas ? ['', `  ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
         ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '', '  ').map(l => l.startsWith('  ') ? l : `  ${l}`)] : []),

package/dist/hitl-tempo-parado.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JANELA_DA_MEDIANA_MS = exports.META_DA_MEDIANA_DE_RESPOSTA_MS = void 0;
+exports.esperasDeHitl = esperasDeHitl;
+exports.resumirTempoParado = resumirTempoParado;
+exports.hitlDeConducaoAgora = hitlDeConducaoAgora;
+exports.lerHitlDeConducaoAgora = lerHitlDeConducaoAgora;
+exports.textoDaMediana = textoDaMediana;
+exports.linhaDaPerguntaParada = linhaDaPerguntaParada;
+exports.linhaDoHitlAcimaDaMeta = linhaDoHitlAcimaDaMeta;
+/**
+ * RM-057 (fatia 2): o tempo parado por HITL de conducao, medido do ledger.
+ *
+ * A metrica principal da RM-057 e o tempo em que a fabrica fica parada esperando o dono numa
+ * pergunta de conducao. A linha de base e a noite de 01 para 02/10/2026: mais de 10 h parada num
+ * "confirmo" em texto livre. A meta e mediana de resposta abaixo de 5 min e nenhum pedido em texto
+ * fora da excecao tecnica.
+ *
+ * O que conta como HITL de conducao: o pedido `ork.hitl/v2` de classe `pergunta` que o ork abriu
+ * (`hitl_requested`). A decisao informada (`decidido`) nao para nada e fica fora; o v1 e a pergunta
+ * nativa de uma sessao do host, com as opcoes do host, e tambem fica fora.
+ *
+ * Quando a espera acaba, na ordem em que o ledger prova:
+ *
+ *   respondido          o primeiro `human_gate` ou `session_answered` com o `pedidoId`;
+ *   seguiu-recomendada  o prazo venceu e o pedido declara `seguir-recomendada` (ele se resolve so);
+ *   substituido         um pedido novo para o mesmo alvo (o velho deixou de ser a pergunta);
+ *   encerrado           a thread fechou (`master_done` ou `thread_closed_admin`) sem resposta;
+ *   aberto              nada disso ainda: a espera corre ate o fim do periodo.
+ *
+ * Limite dito: o "confirmo" que um condutor pede na conversa, fora do ork, nao chega ao ledger e
+ * nao entra aqui. Por isso o canario `fx-pedido-colado` e a regra nos adaptadores existem.
+ *
+ * Funcoes puras sobre eventos: nao leem disco nem relogio. Ausencia de pedido e zero pedidos, e a
+ * mediana sem resposta e `null`, nunca zero inventado. A unica leitura de disco e
+ * `lerHitlDeConducaoAgora`, que so junta os ledgers e entrega a conta as funcoes puras.
+ *
+ * Fatia 3: o mesmo tempo parado chega ao `ork pulse` e ao `ork roadmap status`, com as perguntas
+ * abertas agora (ha quanto tempo cada uma espera) e a mediana dos ultimos 7 dias.
+ */
+const hitl_contract_1 = require("./hitl-contract");
+const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+const locale_1 = require("./locale");
+/** A meta da RM-057: mediana de resposta abaixo de 5 minutos. */
+exports.META_DA_MEDIANA_DE_RESPOSTA_MS = 5 * 60_000;
+const RESPOSTAS = ['human_gate', 'session_answered'];
+const FECHAMENTOS_DA_THREAD = ['master_done', 'thread_closed_admin'];
+function instante(valor) {
+    const t = typeof valor === 'string' ? Date.parse(valor) : NaN;
+    return Number.isFinite(t) ? t : null;
+}
+function formaDaResposta(p) {
+    const pedeTexto = p.tipoDeResposta === 'aberta' || p.respostaAceita?.tipo === 'texto';
+    if (!pedeTexto)
+        return 'selecao';
+    return p.dependenciaTecnica ? 'dependencia' : 'fora-da-excecao';
+}
+function chaveDoAlvo(p) {
+    try {
+        const alvo = (0, hitl_contract_1.alvoDoPedido)(p);
+        if (alvo)
+            return JSON.stringify(alvo);
+    }
+    catch { /* sem alvo legivel */ }
+    return `pedido:${String(p.id)}`;
+}
+/** As esperas de uma thread, em ordem de abertura. Le so o ledger dela. */
+function esperasDeHitl(thread, eventos) {
+    const esperas = [];
+    const vistos = new Set();
+    for (const e of eventos) {
+        if (e.tipo !== 'hitl_requested')
+            continue;
+        const p = e.pedido;
+        if (!p || typeof p !== 'object' || !(0, hitl_contract_1.ehV2)(p) || p.classe !== 'pergunta' || vistos.has(String(p.id)))
+            continue;
+        const inicioMs = instante(p.criadoEm) ?? instante(e.ts);
+        if (inicioMs === null)
+            continue;
+        vistos.add(String(p.id));
+        esperas.push({ thread, pedidoId: String(p.id), fase: String(p.fase), inicioMs, fimMs: null, fim: 'aberto',
+            forma: formaDaResposta(p), alvo: chaveDoAlvo(p), prazoMs: instante(p.prazo),
+            seguir: p.acaoPadraoAoExpirar === 'seguir-recomendada' });
+    }
+    const fechar = (x, fimMs, fim) => {
+        if (x.fimMs === null || fimMs < x.fimMs) {
+            x.fimMs = Math.max(fimMs, x.inicioMs);
+            x.fim = fim;
+        }
+    };
+    for (const x of esperas) {
+        const resposta = eventos.find(e => RESPOSTAS.includes(e.tipo) && String(e.pedidoId) === x.pedidoId && instante(e.ts) !== null);
+        if (resposta)
+            fechar(x, instante(resposta.ts), 'respondido');
+        if (x.seguir && x.prazoMs !== null)
+            fechar(x, x.prazoMs, 'seguiu-recomendada');
+        const novo = esperas.find(y => y !== x && y.alvo === x.alvo && y.inicioMs > x.inicioMs);
+        if (novo)
+            fechar(x, novo.inicioMs, 'substituido');
+        const fechou = eventos.find(e => FECHAMENTOS_DA_THREAD.includes(e.tipo) && (instante(e.ts) ?? -Infinity) >= x.inicioMs);
+        if (fechou)
+            fechar(x, instante(fechou.ts), 'encerrado');
+    }
+    return esperas.map(({ alvo: _a, prazoMs: _p, seguir: _s, ...x }) => x);
+}
+function mediana(valores) {
+    if (valores.length === 0)
+        return null;
+    const v = [...valores].sort((a, b) => a - b), m = Math.floor(v.length / 2);
+    return v.length % 2 ? v[m] : (v[m - 1] + v[m]) / 2;
+}
+/** Resume as esperas de todas as threads no periodo `[desdeMs, ateMs)`. */
+function resumirTempoParado(esperas, desdeMs, ateMs) {
+    let pedidos = 0, respondidos = 0, semResposta = 0, abertos = 0, paradoMs = 0, comDependencia = 0, foraDaExcecao = 0;
+    const respostas = [];
+    for (const x of esperas) {
+        const fim = x.fimMs ?? ateMs;
+        const a = Math.max(x.inicioMs, desdeMs), b = Math.min(fim, ateMs);
+        if (b > a)
+            paradoMs += b - a;
+        if (x.inicioMs >= desdeMs && x.inicioMs < ateMs) {
+            pedidos++;
+            if (x.forma === 'dependencia')
+                comDependencia++;
+            if (x.forma === 'fora-da-excecao')
+                foraDaExcecao++;
+        }
+        if (x.fimMs === null || x.fimMs >= ateMs) {
+            if (x.inicioMs < ateMs)
+                abertos++;
+            continue;
+        }
+        if (x.fimMs < desdeMs)
+            continue;
+        if (x.fim === 'respondido') {
+            respondidos++;
+            respostas.push(x.fimMs - x.inicioMs);
+        }
+        else
+            semResposta++;
+    }
+    const med = mediana(respostas);
+    return {
+        pedidos, respondidos, semResposta, abertos, paradoMs,
+        medianaRespostaMs: med, maiorRespostaMs: respostas.length ? Math.max(...respostas) : null,
+        metaMedianaMs: exports.META_DA_MEDIANA_DE_RESPOSTA_MS, dentroDaMeta: med === null ? null : med < exports.META_DA_MEDIANA_DE_RESPOSTA_MS,
+        emTexto: { comDependenciaTecnica: comDependencia, foraDaExcecao },
+    };
+}
+/** RM-057 (fatia 3): a janela da mediana que o pulse e o status mostram. */
+exports.JANELA_DA_MEDIANA_MS = 7 * 24 * 60 * 60_000;
+/** O retrato num instante. Pura: `quando` e o relogio de quem chama. */
+function hitlDeConducaoAgora(esperas, quando) {
+    const agoraMs = Date.parse(quando);
+    const abertas = esperas
+        .filter(x => x.inicioMs <= agoraMs && (x.fimMs === null || x.fimMs > agoraMs))
+        .sort((a, b) => a.inicioMs - b.inicioMs || a.thread.localeCompare(b.thread))
+        .map(x => ({ thread: x.thread, pedidoId: x.pedidoId, fase: x.fase, desdeEm: new Date(x.inicioMs).toISOString(),
+        paradaHaMin: Math.floor((agoraMs - x.inicioMs) / 60_000) }));
+    const seteDias = resumirTempoParado(esperas, agoraMs - exports.JANELA_DA_MEDIANA_MS, agoraMs);
+    const abertaAcima = abertas.some(a => (agoraMs - Date.parse(a.desdeEm)) > exports.META_DA_MEDIANA_DE_RESPOSTA_MS);
+    return { abertas, seteDias, acimaDaMeta: abertaAcima || seteDias.dentroDaMeta === false };
+}
+/** Junta os ledgers de todas as threads do projeto e devolve o retrato. Ledger ilegivel fica de fora. */
+function lerHitlDeConducaoAgora(raiz, quando) {
+    const esperas = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            esperas.push(...esperasDeHitl(id, (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id))));
+        }
+        catch { /* ledger ilegivel nao para o pulse */ }
+    }
+    return hitlDeConducaoAgora(esperas, quando);
+}
+const emMinutos = (ms) => `${(ms / 60_000).toFixed(1)} min`;
+/** "mediana de 7 dias 3.0 min (dentro da meta de 5 min)", ou sem resposta medida. */
+function textoDaMediana(h) {
+    const s = h.seteDias;
+    if (s.medianaRespostaMs === null)
+        return (0, locale_1.msg)().pulse.medianaSemResposta;
+    return (0, locale_1.msg)().pulse.mediana(emMinutos(s.medianaRespostaMs), s.dentroDaMeta, s.respondidos);
+}
+/** "<thread> (<fase>) parada ha 12min, desde 01:02": a hora no fuso do dono (RM-035). */
+function linhaDaPerguntaParada(p, opcoes) {
+    return (0, locale_1.msg)().pulse.perguntaParada(p.thread, p.fase, (0, horario_1.duracaoRelativa)(p.paradaHaMin), (0, horario_1.formatarHora)(p.desdeEm, opcoes));
+}
+/**
+ * A linha unica do resumo do pulse, so quando passou da meta: quantas abertas, a mais antiga e a
+ * mediana. Abaixo da meta, nada: o resumo nao ganha uma linha que nao pede atencao.
+ */
+function linhaDoHitlAcimaDaMeta(h, opcoes) {
+    if (!h || !h.acimaDaMeta)
+        return null;
+    const velha = h.abertas[0];
+    const abertas = h.abertas.length
+        ? `${h.abertas.length} pergunta(s) de condução aberta(s), a mais antiga ${linhaDaPerguntaParada(velha, opcoes)}; `
+        : 'nenhuma pergunta de condução aberta; ';
+    return `HITL de condução acima da meta de 5 min: ${abertas}${textoDaMediana(h)}.`;
+}

package/dist/hitl-texto-livre.js

@@ -10,7 +10,7 @@
  *
  * "Inequivoca" nao e julgamento de ninguem. E esta regra, fechada e pura:
  *
- *   1. o texto tem a forma de uma resposta: letra a-d, digito 1-4, ou uma palavra do VOCABULARIO
+ *   1. o texto tem a forma de uma resposta: letra a-e, digito 1-5, ou uma palavra do VOCABULARIO
  *      (que e uma lista, e nao um classificador), sozinha ou numerada ("1. B, 2. aprovo");
  *   2. a palavra casa com UMA alternativa, pela acao dela ("aprovo" casa `aprovar`; "nao" num gate
  *      casa `recusar` e `esperar`, entao e ambigua e volta como pergunta);
@@ -62,7 +62,7 @@ const PALAVRAS_DA_FORMA = 'pode seguir|pode ir|pode|sim|s|ok|aprovo|aprovado|apr
     'confirmo|confirmado|de acordo|agora n[aã]o|n[aã]o|n|recuso|recusado|recusar|reprovo|reprovado|revisar|revis[aã]o|refazer|' +
     'volta|voltar|esperar|espera|aguardar|aguarda|aguarde|depois|mais tarde|detalhes?|evid[eê]ncias?';
 /** Uma resposta: letra, ou palavra do vocabulario. */
-const RESPOSTA_DA_FORMA = `(?:[a-d]|${PALAVRAS_DA_FORMA})`;
+const RESPOSTA_DA_FORMA = `(?:[a-e]|${PALAVRAS_DA_FORMA})`;
 /**
  * Um item numerado: "1a", "1 a", "1. B", "1) aprovo", "1 - nao", "1: detalhes".
  *
@@ -78,7 +78,7 @@ exports.FORMAS_DO_TEXTO_LIVRE = Object.freeze({
     /** Resposta numerada, uma ou varias, separadas por virgula, ponto e virgula, espaco ou linha. */
     lista: `^[ \\t]*${ITEM_DA_FORMA}(?:[ \\t\\r\\n,;]*${ITEM_DA_FORMA})*[ \\t]*(?:[.!][ \\t]*)?$`,
     /** Resposta solta: letra, digito ou palavra, sozinha na mensagem. */
-    livre: `^[ \\t]*(?:[1-4]|${RESPOSTA_DA_FORMA})[ \\t]*(?:[.!]+[ \\t]*)?$`,
+    livre: `^[ \\t]*(?:[1-5]|${RESPOSTA_DA_FORMA})[ \\t]*(?:[.!]+[ \\t]*)?$`,
 });
 /** Minusculas, sem acento, espaco unico, sem pontuacao final. */
 function normalizarLivre(texto) {
@@ -87,9 +87,9 @@ function normalizarLivre(texto) {
 /** O que um pedaco de resposta quer dizer, ou `null` quando ele nao e resposta. */
 function lerTrecho(bruto) {
     const t = normalizarLivre(bruto);
-    if (/^[a-d]$/.test(t))
+    if (/^[a-e]$/.test(t))
         return { tipo: 'letra', letra: t };
-    if (/^[1-4]$/.test(t))
+    if (/^[1-5]$/.test(t))
         return { tipo: 'digito', numero: Number(t) };
     for (const [intencao, palavras] of Object.entries(exports.VOCABULARIO_LIVRE)) {
         if (palavras.includes(t))