@orkastery/cli 0.5.1 → 0.5.3

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

@@ -29,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';
@@ -59,6 +60,7 @@ 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.hitlDeConducao?.acimaDaMeta ? { hitlDeConducao: opcoes.hitlDeConducao } : {}),
     };
 }
 /** Quantas linhas do condutor o resumo mostra antes de contar o resto. */
@@ -78,6 +80,11 @@ function linhasDoCondutor(r, marcador, recuo) {
     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)})` : '';
@@ -201,6 +208,7 @@ 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, '🧭 ', '   ')] : []),
@@ -232,6 +240,7 @@ 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}`)] : []),

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
 // ---------------------------------------------------------------------------

package/dist/hosts.js

@@ -57,6 +57,7 @@ exports.ORDEM_DOS_HOSTS = exports.HOSTS = exports.MAESTRO_HOST_SURFACES = export
 exports.parseHost = parseHost;
 exports.lerRecibo = lerRecibo;
 exports.classificarDivergencia = classificarDivergencia;
+exports.avisoDoOrkNoPath = avisoDoOrkNoPath;
 exports.renderizarArquivo = renderizarArquivo;
 exports.instalarAdaptador = instalarAdaptador;
 exports.desinstalarExperiencia = desinstalarExperiencia;
@@ -64,6 +65,7 @@ exports.tabelaDeHosts = tabelaDeHosts;
 exports.textoDosPitfalls = textoDosPitfalls;
 exports.textoDaInstalacao = textoDaInstalacao;
 const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 exports.BRAIN_HOST_SURFACES = {
     hermes: 'cli', openclaw: 'cli', 'claude-code': 'mcp', codex: 'mcp',
@@ -246,6 +248,31 @@ function listarArquivos(dir, prefixo = '') {
     }
     return achados;
 }
+function mesmoArquivo(a, b) {
+    try {
+        return fs.realpathSync(a) === fs.realpathSync(b);
+    }
+    catch {
+        return path.resolve(a) === path.resolve(b);
+    }
+}
+/**
+ * Ensaio de 03/10: com outro `ork` primeiro no PATH, a extensão segue apontando para o binário que roda o
+ * install, e o aviso diz as duas versões para ninguém descobrir a diferença pela extensão chamando o velho.
+ */
+function avisoDoOrkNoPath(emExecucao, versao, env = process.env) {
+    const doPath = (0, util_1.noPath)('ork', env);
+    if (!doPath || mesmoArquivo(doPath, emExecucao))
+        return undefined;
+    let outra = 'versão desconhecida';
+    try {
+        const saida = (0, node_child_process_1.execFileSync)(doPath, ['--version'], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], env });
+        outra = saida.trim().split('\n')[0]?.trim() || outra;
+    }
+    catch { /* o aviso sai mesmo sem a versão */ }
+    return `o ork do PATH (${doPath}, ${outra}) não é o que roda este install (${emExecucao}, ${versao}). ` +
+        `A extensão chama ${emExecucao}; para outro binário, passe --ork <caminho>.`;
+}
 /** Substitui os tres placeholders. Nao ha template engine aqui de proposito. */
 function renderizarArquivo(conteudo, valores) {
     return conteudo
@@ -267,8 +294,10 @@ function instalarAdaptador(host, opcoes = {}) {
         ? path.resolve(projeto, opcoes.dir)
         : path.join(projeto, def.destinoPadrao);
     const destino = def.subdir ? path.join(base, def.subdir) : base;
-    const orkBin = opcoes.orkBin ?? (0, util_1.noPath)('ork') ?? (0, catalogo_1.cliDoCatalogo)(catalogo);
+    const orkBin = opcoes.orkBin ?? opcoes.orkEmExecucao ?? (0, util_1.noPath)('ork') ?? (0, catalogo_1.cliDoCatalogo)(catalogo);
     const versao = opcoes.versao ?? versao_1.VERSAO_DO_ORK;
+    const avisoOrk = opcoes.orkBin === undefined && opcoes.orkEmExecucao
+        ? avisoDoOrkNoPath(opcoes.orkEmExecucao, versao) : undefined;
     const dirDoHost = path.join(catalogo, 'adapters', host);
     if (!fs.existsSync(dirDoHost)) {
         throw new Error(`adaptador do host ${host} nao existe em ${dirDoHost}`);
@@ -424,6 +453,7 @@ function instalarAdaptador(host, opcoes = {}) {
         ...(reciboVizinho ? { reciboVizinho } : {}),
         ok: !barrado,
         orkBin,
+        ...(avisoOrk ? { avisoOrk } : {}),
         pitfalls: def.pitfalls,
         ...(preferencias || avisoExperiencia ? { experiencia: { ativa: host !== 'openclaw' && !!preferencias?.experience && !avisoExperiencia,
                 arquivos: planoExperiencia?.mudancas.map(m => path.relative(planoExperiencia.projeto, m.arquivo)) ?? [], skill: preferencias?.skill ?? '',
@@ -523,28 +553,35 @@ function textoDaInstalacao(r) {
         : r.ok
             ? `Arquivos do adaptador ${r.host} preparados.`
             : `Instalacao do adaptador ${r.host} BARRADA: ha arquivo diferente no destino.`);
+    // Ensaio de 03/10 (R6): a ativacao sai no comeco e de novo no fim, depois da lista de arquivos e dos
+    // pitfalls, para que o fim da saida diga o proximo passo.
+    const ativacao = [];
     if (r.ok && !r.dryRun && r.host === 'claude-code') {
         const destino = "'" + r.destino.replace(/'/g, "'\"'\"'") + "'";
         linhas.push('Uso no Claude Code ainda nao verificado por esta copia.');
         linhas.push('No diretorio deste projeto, valide e ative o plugin:');
-        linhas.push(`  claude plugin validate ${destino}`);
-        linhas.push(`  claude plugin marketplace add ${destino} --scope project`);
-        linhas.push('  claude plugin install orkastery@orkastery --scope project');
-        linhas.push('  claude plugin list --json');
-        linhas.push('Depois, na sessao deste projeto: /orkastery:ork');
+        ativacao.push(`  claude plugin validate ${destino}`);
+        ativacao.push(`  claude plugin marketplace add ${destino} --scope project`);
+        ativacao.push('  claude plugin install orkastery@orkastery --scope project');
+        ativacao.push('  claude plugin list --json');
+        ativacao.push('Depois, na sessao deste projeto: /orkastery:ork');
     }
     else if (r.ok && !r.dryRun && r.host === 'codex') {
-        linhas.push('Abra o Codex neste projeto e use $ork.');
-        linhas.push('Descoberta e uso nativo ainda nao verificados por esta copia.');
+        ativacao.push('Abra o Codex neste projeto e use $ork.');
+        ativacao.push('Descoberta e uso nativo ainda nao verificados por esta copia.');
     }
     if (r.ok && !r.dryRun && (r.host === 'codex' || r.host === 'claude-code')) {
         const projeto = "'" + r.projeto.replace(/'/g, "'\"'\"'") + "'";
-        linhas.push(`Prepare tambem as ferramentas do projeto: ork mcp install --project ${projeto} --host ${r.host}`);
-        linhas.push('A configuracao MCP exige descoberta e consentimento no cliente; a copia nao concede aprovacoes.');
+        ativacao.push(`Prepare tambem as ferramentas do projeto: ork mcp install --project ${projeto} --host ${r.host}`);
     }
+    linhas.push(...ativacao);
+    if (ativacao.length)
+        linhas.push('A configuracao MCP exige descoberta e consentimento no cliente; a copia nao concede aprovacoes.');
     linhas.push(`  catalogo: ${r.catalogo}`);
     linhas.push(`  destino:  ${r.destino}`);
     linhas.push(`  ork:      ${r.orkBin}`);
+    if (r.avisoOrk)
+        linhas.push(`  Aviso: ${r.avisoOrk}`);
     linhas.push('');
     const novos = r.arquivos.filter((a) => a.estado === 'novo').length;
     const iguais = r.arquivos.filter((a) => a.estado === 'igual').length;
@@ -592,5 +629,10 @@ function textoDaInstalacao(r) {
     }
     linhas.push('');
     linhas.push(textoDosPitfalls(r.host));
+    if (ativacao.length) {
+        linhas.push('');
+        linhas.push(r.host === 'claude-code' ? 'Proximo passo, no diretorio deste projeto (o mesmo do comeco):' : 'Proximo passo (o mesmo do comeco):');
+        linhas.push(...ativacao);
+    }
     return linhas.join('\n');
 }