@orkastery/cli 0.5.0 → 0.5.3

package/dist/forja.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mesmaForja = exports.rotuloDaForja = exports.executorPadrao = void 0;
+exports.enderecoDoRemoto = enderecoDoRemoto;
+exports.repositorioGithubNoHost = repositorioGithubNoHost;
 exports.identidadeDaForja = identidadeDaForja;
 exports.forjaDoArgumento = forjaDoArgumento;
 exports.detalheSeguro = detalheSeguro;
@@ -27,14 +29,20 @@ exports.lerDaForja = lerDaForja;
 const node_child_process_1 = require("node:child_process");
 const hitl_1 = require("./hitl");
 const policies_1 = require("./policies");
+const rede_forja_1 = require("./rede-forja");
 const PRAZO_MS = 30000;
 const SHA = /^[0-9a-f]{40}$/;
 const SEGMENTO = /^[A-Za-z0-9_.-]+$/;
 /** Hostname de verdade: rotulos alfanumericos separados por ponto (`..` ou `a..b` nao passam). */
 const HOST = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/;
-/** Sem shell, sem token: a CLI usa a autenticacao que ja tem; prompt e aviso de versao desligados. */
+/**
+ * Sem shell, sem token: a CLI usa a autenticacao que ja tem; prompt e aviso de versao desligados.
+ * RM-054 (fatia 3): o binario e procurado como na rede (D11 da RM-053), no PATH e depois nas pastas de
+ * usuario (`~/.local/bin` e as outras): o gateway e o cron rodam com PATH curto, e o `gh` da srvjcp86
+ * mora em `~/.local/bin`. Sem achar, o nome vai cru ao spawn, e o ENOENT continua `forja.ausente`.
+ */
 const executorPadrao = (cmd, args, entrada, timeoutMs) => {
-    const r = (0, node_child_process_1.spawnSync)(cmd, [...args], {
+    const r = (0, node_child_process_1.spawnSync)((0, rede_forja_1.acharBinario)(cmd) ?? cmd, [...args], {
         input: entrada, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 32 * 1024 * 1024,
         env: { ...process.env, GH_PROMPT_DISABLED: '1', GH_NO_UPDATE_NOTIFIER: '1', GLAB_CHECK_UPDATE: 'false', NO_COLOR: '1' },
     });
@@ -63,10 +71,10 @@ function montar(tipo, host, caminho) {
     return { tipo, host, repo: partes.join('/') };
 }
 /**
- * A forja de uma URL de remoto (https, ssh ou scp). Credencial na URL nunca entra na identidade;
- * caminho local e forja desconhecida voltam null.
+ * RM-037 (fatia 5, A5): o host e o caminho de uma URL de remoto (https, ssh ou scp), de qualquer forja. Credencial
+ * na URL nunca entra; caminho local e host que nao e hostname voltam null.
  */
-function identidadeDaForja(url) {
+function enderecoDoRemoto(url) {
     const t = url.trim();
     const esquema = /^(?:https?|ssh|git|git\+ssh|ssh\+git):\/\/(?:[^@/]*@)?([^/:?#@]+)(?::\d+)?\/([^?#\s]+)$/i.exec(t);
     const scp = esquema ? null : /^(?:[^@\s/:]+@)?([^:\s/@]+):(?!\/\/)([^\s]+)$/.exec(t);
@@ -74,8 +82,24 @@ function identidadeDaForja(url) {
     if (!achado)
         return null;
     const host = achado[1].toLowerCase();
-    const tipo = tipoDoHost(host);
-    return tipo ? montar(tipo, host, achado[2].replace(/^\/+/, '')) : null;
+    return HOST.test(host) ? { host, caminho: achado[2].replace(/^\/+/, '') } : null;
+}
+/**
+ * RM-037 (fatia 5, A5): o `dono/nome` de um repositorio do GitHub no host do remoto, com qualquer host: o GitHub
+ * Enterprise mora em host proprio, com ou sem "github" no nome. Quem diz se o host e mesmo um GitHub e o `gh`.
+ */
+function repositorioGithubNoHost(url) {
+    const endereco = enderecoDoRemoto(url);
+    return endereco && tipoDoHost(endereco.host) !== 'gitlab' ? montar('github', endereco.host, endereco.caminho) : null;
+}
+/**
+ * A forja de uma URL de remoto (https, ssh ou scp). Credencial na URL nunca entra na identidade;
+ * caminho local e forja desconhecida voltam null.
+ */
+function identidadeDaForja(url) {
+    const endereco = enderecoDoRemoto(url);
+    const tipo = endereco ? tipoDoHost(endereco.host) : null;
+    return endereco && tipo ? montar(tipo, endereco.host, endereco.caminho) : null;
 }
 /** `github:dono/repo`, `gitlab:grupo/sub/repo` (com host proprio: `gitlab:host.tld/grupo/repo`) ou uma URL. */
 function forjaDoArgumento(texto) {

package/dist/gates.js

@@ -46,11 +46,15 @@ exports.DESCRICAO_DO_MOTIVO = {
     'runtime.quota-exhausted': 'a cota ou os creditos da conta do runtime acabaram (I-33: o perfil sai do rodizio e a fase segue em outro perfil, outro runtime ou na fila)',
     'runtime.auth-missing': 'a conta do runtime nao esta autenticada (I-33: o perfil nunca recebe despacho ate o login ser refeito pelo proprio CLI)',
     'runtime.model-unavailable': 'o modelo pedido nao existe ou a conta nao tem acesso a ele (RM-037: o perfil segue no rodizio e a fase vai a outro perfil com o mesmo modelo ou ao fallback do bloco)',
+    'runtime.profile-invalid': 'o perfil pedido no despacho (--perfil) nao existe no store ou e de outro runtime (RM-056: o despacho nunca troca de perfil sozinho)',
+    'runtime.workspace-untrusted': 'o runtime nao confia no diretorio da worktree e recusou o despacho (RM-055: so o dono aceita a confianca no terminal; depois o ork re-despacha o mesmo prompt)',
+    'runtime.consent-pending': 'o runtime espera o dono aceitar termos novos e recusou o despacho (RM-055: so o dono aceita no terminal; depois o ork re-despacha o mesmo prompt)',
     'cost.violation': 'o despacho seria redirecionado para provider pago (violacao de custo: e o unico motivo que NUNCA recebe retry automatico)',
     'tree.blocked': 'a arvore de destino nao esta disponivel para o merge (branch em check-out com alteracao nao commitada, ou worktree que nao pode ser montada)',
     'lease.busy': 'lease ocupado por outra thread',
+    'lease.resume-unavailable': 'retomada indisponivel; libere o lease explicitamente com --forcar',
     'conducao.em-andamento': 'outra conducao ja executa na worktree da thread (I-36): o pedido foi recusado com quem conduz e as tres acoes (esperar, acompanhar, assumir)',
-    'hitl.formato': 'o pedido HITL saiu fora do formato obrigatorio (pergunta em uma frase, de 2 a 4 alternativas rotuladas com consequencia, exatamente uma recomendada com o porque, corpo em lista)',
+    'hitl.formato': 'o pedido HITL saiu fora do formato obrigatorio (pergunta em uma frase, de 3 a 5 alternativas rotuladas com consequencia, exatamente uma com o selo Recomendacao e o porque, corpo em lista; texto livre so com dependencia tecnica tipada)',
     'human.pending': 'gate humano do modo de conducao ainda nao autorizou',
 };
 /**

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-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,7 +1,9 @@
 "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_THREADS_NOMEADAS = exports.PERGUNTA_DO_RESUMO = exports.CONTRATO_RESUMO = void 0;
+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.resumirHitl = resumirHitl;
+exports.linhaDoParadoNoCondutor = linhaDoParadoNoCondutor;
+exports.linhasDoCondutor = linhasDoCondutor;
 exports.linhaDosTecnicos = linhaDosTecnicos;
 exports.linhasDasOutrasMaquinas = linhasDasOutrasMaquinas;
 exports.linhasDasDecisoes = linhasDasDecisoes;
@@ -27,6 +29,7 @@ exports.textoDoResumo = textoDoResumo;
  * mensagem do canal. Quem entrega chama a segunda.
  */
 const horario_1 = require("./horario");
+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';
@@ -55,8 +58,33 @@ function resumirHitl(itens, opcoes) {
         ...(opcoes.outrasMaquinas?.length ? { outrasMaquinas: opcoes.outrasMaquinas.map(m => ({ ...m, esperando: [...m.esperando] })) } : {}),
         tecnicos: tecnicos.length,
         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.hitlDeConducao?.acimaDaMeta ? { hitlDeConducao: opcoes.hitlDeConducao } : {}),
     };
 }
+/** Quantas linhas do condutor o resumo mostra antes de contar o resto. */
+exports.TETO_DE_PARADOS_NO_CONDUTOR = 5;
+/**
+ * RM-037 (fatia 4): "<thread> parado no condutor desde HH:MM: <proximo passo>", a mesma frase no pulse,
+ * no resumo dos dois canais e no status do roadmap. O horario sai no fuso do dono.
+ */
+function linhaDoParadoNoCondutor(p, opcoes) {
+    const { desdeEm: desde } = p;
+    return `${p.thread} parado no condutor desde ${(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) {
+    const parados = r.paradosNoCondutor ?? [];
+    const mostradas = parados.slice(0, exports.TETO_DE_PARADOS_NO_CONDUTOR), sobra = parados.length - mostradas.length;
+    return [...mostradas.map(p => `${marcador}${linhaDoParadoNoCondutor(p, { agora: r.consultadoEm })}`),
+        ...(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)})` : '';
@@ -180,6 +208,8 @@ function textoTelegram(r, codigo) {
         `❓ ${linhaDasPerguntas(r.prontas)}`,
         ...(r.tecnicos ? [`🔧 ${linhaDosTecnicos(r)}`] : []),
         ...(r.consertos ? [`🔧 ${linhaDosConsertos(r.consertos)}`] : []),
+        ...linhaDoHitlParado(r).map(l => `⏳ ${l}`),
+        ...(r.paradosNoCondutor?.length ? ['', ...linhasDoCondutor(r, '🚧 ', '   ')] : []),
         ...(r.acumuladas ? ['', `📥 ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
         ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '🧭 ', '   ')] : []),
         ...(r.outrasMaquinas?.length ? ['', ...linhasDasOutrasMaquinas(r, '🖥️ ', '   ')] : []),
@@ -210,6 +240,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.paradosNoCondutor?.length ? ['', ...linhasDoCondutor(r, '  ', '  ')] : []),
         ...(r.acumuladas ? ['', `  ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
         ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '', '  ').map(l => l.startsWith('  ') ? l : `  ${l}`)] : []),
         ...(r.outrasMaquinas?.length ? ['', ...linhasDasOutrasMaquinas(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");
+/** 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 'mediana de 7 dias sem resposta medida';
+    return `mediana de 7 dias ${emMinutos(s.medianaRespostaMs)} (${s.dentroDaMeta ? 'dentro' : 'acima'} da meta de 5 min, ` +
+        `${s.respondidos} resposta(s))`;
+}
+/** "<thread> (<fase>) parada ha 12min, desde 01:02": a hora no fuso do dono (RM-035). */
+function linhaDaPerguntaParada(p, opcoes) {
+    return `${p.thread} (${p.fase}) parada há ${(0, horario_1.duracaoRelativa)(p.paradaHaMin)}, desde ${(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))

package/dist/horario.js

@@ -22,6 +22,7 @@ exports.definirFusoDoDono = definirFusoDoDono;
 exports.fusoDoDono = fusoDoDono;
 exports.partesLocais = partesLocais;
 exports.dataLocal = dataLocal;
+exports.instanteNoFuso = instanteNoFuso;
 exports.duracaoCurta = duracaoCurta;
 exports.duracaoRelativa = duracaoRelativa;
 exports.rotuloDoFuso = rotuloDoFuso;
@@ -153,6 +154,32 @@ function dataLocal(quando, fuso = fusoDoDono().fuso) {
     const p = partesLocais(quando, fuso);
     return `${p.ano}-${p.mes}-${p.dia}`;
 }
+/** Quanto o relógio do fuso está à frente do UTC no instante, em milissegundos. */
+function desvioDoFuso(ms, fuso) {
+    const p = partesLocais(ms, fuso);
+    return Date.UTC(Number(p.ano), Number(p.mes) - 1, Number(p.dia), Number(p.hora), Number(p.minuto), Number(p.segundo)) -
+        Math.floor(ms / 1000) * 1000;
+}
+/**
+ * RM-037 (fatia 5): o instante de um relógio num fuso IANA (mês de 1 a 12). O runtime diz a hora de
+ * volta da cota no fuso dele (`resets 4:40am (<fuso>)`), e lê-la no relógio desta máquina errava o
+ * prazo em quem roda noutro fuso. Fuso que o Intl recusa e data que não existe voltam NaN, sem chute.
+ * Na volta do horário de verão vale o primeiro dos dois instantes; o relógio que o salto pula cai
+ * depois do salto.
+ */
+function instanteNoFuso(ano, mes, dia, hora, minuto, fuso) {
+    const nome = normalizarFuso(fuso);
+    const base = Date.UTC(ano, mes - 1, dia, hora, minuto, 0, 0);
+    const data = new Date(Date.UTC(ano, mes - 1, dia));
+    if (!nome || !Number.isFinite(base) || data.getUTCFullYear() !== ano || data.getUTCMonth() !== mes - 1 ||
+        data.getUTCDate() !== dia)
+        return NaN;
+    // Os desvios de um dia antes e de um dia depois cobrem os dois lados de qualquer mudança de horário.
+    const candidatos = [...new Set([base - 86400000, base, base + 86400000].map((ms) => base - desvioDoFuso(ms, nome)))]
+        .sort((a, b) => a - b);
+    const exatos = candidatos.filter((ms) => ms + desvioDoFuso(ms, nome) === base);
+    return exatos[0] ?? base - desvioDoFuso(base - 86400000, nome);
+}
 // ---------------------------------------------------------------------------
 // Texto para pessoa
 // ---------------------------------------------------------------------------