@orkastery/cli 0.2.0 → 0.4.1

package/dist/orquestracao.js

@@ -61,9 +61,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ATENCAO_PADRAO_MIN = void 0;
+exports.duracaoCurta = exports.ATENCAO_PADRAO_MIN = void 0;
 exports.minutosEntre = minutosEntre;
-exports.duracaoCurta = duracaoCurta;
 exports.montarMonitor = montarMonitor;
 exports.textoDoMonitor = textoDoMonitor;
 const adapter = __importStar(require("./adapters/claude-bg"));
@@ -71,36 +70,17 @@ const board_1 = require("./board");
 const gates_1 = require("./gates");
 const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
+const ocupacao_1 = require("./ocupacao");
 const ratelimit_1 = require("./ratelimit");
+const hitl_1 = require("./hitl");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const horario_1 = require("./horario");
+Object.defineProperty(exports, "duracaoCurta", { enumerable: true, get: function () { return horario_1.duracaoCurta; } });
+const conducao_1 = require("./conducao");
+const conducao_texto_1 = require("./conducao-texto");
 /** Limite de atencao padrao, em minutos: parada mais velha que isso e destacada. */
 exports.ATENCAO_PADRAO_MIN = 30;
-/** Estado que o `ork phase run` grava quando o bloco despachado pausa ao fim. */
-const PAUSA_PREVISTA = 'prevista ao fim do bloco';
-/**
- * Eventos que destravam uma reprovacao de gate.
- *
- * `phase_dispatch` entra pela porta da frente: o `ork phase run` grava `gate_blocked`
- * ANTES de despachar e aborta o despacho, entao um `phase_dispatch` posterior so existe
- * se aquele bloqueio deixou de valer.
- */
-const EVENTOS_QUE_DESTRAVAM = [
-    ledger_1.TIPOS_DE_EVENTO.gateLiberado,
-    ledger_1.TIPOS_DE_EVENTO.faseDespachada,
-    ledger_1.TIPOS_DE_EVENTO.leaseAdquirido,
-    ledger_1.TIPOS_DE_EVENTO.rateLimitRetomado,
-    ledger_1.TIPOS_DE_EVENTO.shipConcluido,
-    ledger_1.TIPOS_DE_EVENTO.masterConcluido,
-];
-/** O evento e uma autorizacao humana ja registrada (`ork gate approve`)? */
-function ehAprovacaoHumana(e) {
-    return e.tipo === ledger_1.TIPOS_DE_EVENTO.pausaHumana && e.estado === 'aprovado';
-}
-/** O evento e a pausa PREVISTA gravada no despacho do ultimo bloco? */
-function ehPausaPrevista(e) {
-    return e.tipo === ledger_1.TIPOS_DE_EVENTO.pausaHumana && e.estado === PAUSA_PREVISTA;
-}
 /** Minutos inteiros entre dois carimbos ISO (nunca negativo). */
 function minutosEntre(desdeEm, ateEm) {
     const inicio = Date.parse(desdeEm);
@@ -109,15 +89,6 @@ function minutosEntre(desdeEm, ateEm) {
         return 0;
     return Math.max(0, Math.floor((fim - inicio) / 60000));
 }
-/** Duracao curta para a tabela: `12min`, `3h05`, `2d 04h`. */
-function duracaoCurta(minutos) {
-    if (minutos < 60)
-        return `${minutos}min`;
-    const horas = Math.floor(minutos / 60);
-    if (horas < 24)
-        return `${horas}h${String(minutos % 60).padStart(2, '0')}`;
-    return `${Math.floor(horas / 24)}d ${String(horas % 24).padStart(2, '0')}h`;
-}
 /** Indice da fase no ciclo REAL da thread (a variante de ciclo pode encurtar o ciclo). */
 function indiceDaFase(thread, fase) {
     return typeof fase === 'string' ? thread.fases.indexOf(fase) : -1;
@@ -140,8 +111,8 @@ function blocoDaFase(thread, fase) {
     }
 }
 /** Comando que o humano roda para liberar uma pausa da thread. */
-function comandoDeAprovacao(threadId, sobre) {
-    return `ork gate approve ${threadId} "${sobre || 'pausa'}" --por <quem>`;
+function comandoDeAprovacao(threadId, _sobre) {
+    return `ork gate request ${threadId}`;
 }
 function parada(dados, quando) {
     return { ...dados, paradaHaMin: minutosEntre(dados.desdeEm, quando) };
@@ -152,7 +123,7 @@ function parada(dados, quando) {
  * Tres fontes, na ordem de confianca. A mesma fase nunca vira duas linhas: a primeira
  * fonte que a reivindica fica com ela, e as demais so acrescentam evidencia.
  */
-function pausasAbertas(thread, eventos, vivas, quando) {
+function pausasAbertas(thread, eventos, estados, quando) {
     const porFase = new Map();
     if (thread.status === 'fechada')
         return [];
@@ -160,12 +131,18 @@ function pausasAbertas(thread, eventos, vivas, quando) {
     // sessao que a produziu. Aberta enquanto ninguem aprovou e a conducao nao passou
     // para uma fase POSTERIOR (redespachar a mesma fase nao resolve pausa nenhuma).
     eventos.forEach((e, i) => {
-        if (!ehPausaPrevista(e))
+        if (!(0, ocupacao_1.ehPausaPrevista)(e))
             return;
         const fase = faseDoEvento(thread, e);
+        // A previsão antiga não substitui o modo corrente nem cria pausa intermediária.
+        if (!fase)
+            return;
+        const previsto = (0, thread_1.blocoDaThread)(thread, fase);
+        if (!previsto.pausa || previsto.fases.at(-1) !== fase)
+            return;
         const iFase = fase ? thread.fases.indexOf(fase) : -1;
         const resolvida = eventos.slice(i + 1).some((p) => {
-            if (ehAprovacaoHumana(p))
+            if ((0, ocupacao_1.ehAprovacaoHumana)(p))
                 return true;
             if (p.tipo === ledger_1.TIPOS_DE_EVENTO.masterConcluido)
                 return true;
@@ -174,7 +151,12 @@ function pausasAbertas(thread, eventos, vivas, quando) {
         if (resolvida)
             return;
         const sessionId = typeof e.sessionId === 'string' ? e.sessionId : '';
-        const sessaoViva = vivas === null ? null : vivas.has(sessionId);
+        // "Viva" aqui quer dizer TRABALHANDO, e nao "aparece na lista do runtime". Foi essa
+        // confusao que deixou passar o incidente de 05/09/2026: a sessao travada em HITL
+        // continua listada, e o monitor a lia como uma sessao que ainda ia terminar. Uma
+        // sessao `blocked` e o contrario disso -- ela e a pausa, ja chegada.
+        const sessaoEstado = estados === null ? null : estados.get(sessionId) ?? null;
+        const sessaoViva = estados === null ? null : sessaoEstado === 'working' || sessaoEstado === '';
         const sobre = typeof e.previstaSobre === 'string' && e.previstaSobre !== ''
             ? e.previstaSobre
             : blocoDaFase(thread, fase).pausaSobre;
@@ -186,12 +168,19 @@ function pausasAbertas(thread, eventos, vivas, quando) {
             bloco: blocoDaFase(thread, fase).bloco,
             pausaSobre: sobre,
             detalhe: sessaoViva === true
-                ? `a sessao ${sessionId.slice(0, 8)} do bloco ainda esta viva no runtime: a pausa chega quando ela terminar`
-                : `bloco fechado em ${fase ?? '?'}: espera o veredito humano sobre ${sobre || 'a pausa do bloco'}`,
-            evidencia: `ledger ${ledger_1.TIPOS_DE_EVENTO.pausaHumana} (${PAUSA_PREVISTA})${sessionId ? `, sessao ${sessionId.slice(0, 8)}` : ''}`,
-            correcao: comandoDeAprovacao(thread.id, sobre),
+                ? `a sessao ${sessionId.slice(0, 8)} do bloco ainda esta trabalhando no runtime: a pausa chega quando ela terminar`
+                : sessaoEstado === 'blocked'
+                    ? `a sessao ${sessionId.slice(0, 8)} do bloco esta BLOQUEADA no runtime esperando acao humana (prompt, permissao ou credencial): veja \`ork sessions hitl\``
+                    : `bloco fechado em ${fase ?? '?'}: espera o veredito humano sobre ${sobre || 'a pausa do bloco'}`,
+            evidencia: `ledger ${ledger_1.TIPOS_DE_EVENTO.pausaHumana} (${ocupacao_1.PAUSA_PREVISTA})` +
+                `${sessionId ? `, sessao ${sessionId.slice(0, 8)}` : ''}` +
+                `${sessaoEstado ? ` em state=${sessaoEstado}` : ''}`,
+            correcao: sessaoEstado === 'blocked'
+                ? `ork sessions logs ${sessionId.slice(0, 8)} para ver o que a sessao pede, e claude attach ${sessionId} para responder`
+                : comandoDeAprovacao(thread.id, sobre),
             desdeEm: e.ts,
             sessaoViva,
+            sessaoEstado,
             fonte: 'ledger',
         }, quando));
     });
@@ -203,7 +192,7 @@ function pausasAbertas(thread, eventos, vivas, quando) {
             return;
         const resolvido = eventos
             .slice(i + 1)
-            .some((p) => EVENTOS_QUE_DESTRAVAM.includes(p.tipo) || ehAprovacaoHumana(p));
+            .some((p) => ocupacao_1.EVENTOS_QUE_DESTRAVAM.includes(p.tipo) || (0, ocupacao_1.ehAprovacaoHumana)(p));
         if (resolvido)
             return;
         const fase = faseDoEvento(thread, e);
@@ -232,7 +221,7 @@ function pausasAbertas(thread, eventos, vivas, quando) {
     // Fonte 3: `status: pausada` carimbado no proprio `thread.json`. E a fonte mais fraca
     // (nao diz sobre o que) e a mais duravel (sobrevive a ledger truncado), entao ela so
     // entra quando a fase atual ainda nao virou linha.
-    if (thread.status === 'pausada' && !porFase.has(thread.faseAtual)) {
+    if (thread.status === 'pausada' && (0, ocupacao_1.faseTemPausaPrevista)(thread) && !porFase.has(thread.faseAtual)) {
         const { bloco, pausaSobre } = blocoDaFase(thread, thread.faseAtual);
         porFase.set(thread.faseAtual, parada({
             natureza: 'pausa-humana',
@@ -285,7 +274,7 @@ function impedimentosAbertos(item, eventos, raizDoProjeto, quando) {
             bloco: blocoDaFase(thread, p.fase).bloco,
             pausaSobre: '',
             detalhe: `pedido ${p.id} na fila de rate limit, libera ${(0, ratelimit_1.faltaPara)(p, quando)} ` +
-                `(${p.liberaEm.replace('T', ' ').slice(0, 16)}, ${p.janelaEstimada ? 'janela estimada' : 'hora dita pelo runtime'})`,
+                `(${p.liberaEm}, ${p.janelaEstimada ? 'janela estimada' : 'hora dita pelo runtime'})`,
             evidencia: `.orkastery/retry/fila.jsonl (${p.id}, ${p.sinal.fonte})`,
             correcao: `ork retry resume --id ${p.id}`,
             desdeEm: p.criadoEm,
@@ -296,7 +285,7 @@ function impedimentosAbertos(item, eventos, raizDoProjeto, quando) {
     // 3. Gates tipados reprovados que ninguem destravou. `human.pending` sai daqui porque
     // ele ja e pausa humana, e `claims.unverifiable` avisa mas nao bloqueia.
     eventos.forEach((e, i) => {
-        if (e.tipo !== ledger_1.TIPOS_DE_EVENTO.gateBloqueado)
+        if (e.tipo !== ledger_1.TIPOS_DE_EVENTO.gateBloqueado && e.tipo !== 'phase_wait')
             return;
         const motivo = e.motivo;
         if (motivo === 'human.pending' || motivo === 'claims.unverifiable')
@@ -304,11 +293,12 @@ function impedimentosAbertos(item, eventos, raizDoProjeto, quando) {
         if (!(motivo in gates_1.DESCRICAO_DO_MOTIVO))
             return;
         // Lease e rate limit ja tem fila propria em disco, que e a fonte mais fresca.
-        if (motivo === 'lease.busy' || motivo === 'runtime.rate-limited')
+        if ((motivo === 'lease.busy' || motivo === 'runtime.rate-limited') &&
+            saida.some(p => p.motivo === motivo))
             return;
         const resolvido = eventos
             .slice(i + 1)
-            .some((p) => EVENTOS_QUE_DESTRAVAM.includes(p.tipo) || ehAprovacaoHumana(p));
+            .some((p) => ocupacao_1.EVENTOS_QUE_DESTRAVAM.includes(p.tipo) || (0, ocupacao_1.ehAprovacaoHumana)(p));
         if (resolvido)
             return;
         const fase = faseDoEvento(thread, e);
@@ -321,7 +311,7 @@ function impedimentosAbertos(item, eventos, raizDoProjeto, quando) {
             detalhe: typeof e.detalhe === 'string' && e.detalhe !== ''
                 ? e.detalhe
                 : gates_1.DESCRICAO_DO_MOTIVO[motivo],
-            evidencia: `ledger ${ledger_1.TIPOS_DE_EVENTO.gateBloqueado} (gate ${String(e.gate ?? '?')})`,
+            evidencia: `ledger ${e.tipo} (gate ${String(e.gate ?? '?')})`,
             correcao: typeof e.correcao === 'string' && e.correcao !== ''
                 ? e.correcao
                 : `ork retry plan ${thread.id} --motivo ${motivo}`,
@@ -336,7 +326,7 @@ function impedimentosAbertos(item, eventos, raizDoProjeto, quando) {
 function situacaoDerivada(item, temPausa) {
     if (item.thread.status === 'fechada')
         return 'fechada';
-    if (item.thread.status === 'pausada' || temPausa)
+    if ((item.thread.status === 'pausada' && (0, ocupacao_1.faseTemPausaPrevista)(item.thread)) || temPausa)
         return 'pausada';
     if (item.leases.length > 0)
         return 'em-andamento';
@@ -374,11 +364,18 @@ function montarMonitor(carregado, opcoes = {}) {
     const itens = (0, board_1.threadsDeTodosOsPerfis)(carregado, todos);
     // O runtime e a unica fonte que sabe se a sessao do bloco ainda trabalha. Sem ele, a
     // pausa prevista e reportada como valendo: avisar a mais e a postura correta aqui.
-    let vivas = null;
+    let estados = null;
     let runtimeDetalhe = 'runtime nao consultado por --sem-runtime';
-    if (opcoes.semRuntime !== true) {
+    if (opcoes.estados !== undefined) {
+        estados = opcoes.estados;
+        runtimeDetalhe = estados === null ? 'consulta de runtime indisponível' : '';
+    }
+    else if (opcoes.semRuntime !== true) {
         if (adapter.disponivel()) {
-            vivas = new Set(adapter.listarSessoes().map((s) => s.sessionId).filter((s) => !!s));
+            estados = new Map(adapter
+                .listarSessoes()
+                .filter((s) => !!s.sessionId)
+                .map((s) => [s.sessionId, (0, hitl_1.estadoBruto)(s)]));
             runtimeDetalhe = '';
         }
         else {
@@ -386,15 +383,31 @@ function montarMonitor(carregado, opcoes = {}) {
         }
     }
     // O escalonador so conhece o perfil do manifesto; os demais caem na situacao derivada.
-    const vagas = new Map((0, board_1.planejar)(carregado).vagas.map((v) => [v.thread, v]));
+    // Os estados de sessao ja consultados vao junto: uma chamada ao runtime, nao duas.
+    const vagas = new Map((0, board_1.planejar)(carregado, { agora: quando, estados }).vagas.map((v) => [v.thread, v]));
     const linhas = [];
     for (const item of itens) {
         const { thread } = item;
         const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(item.raiz, thread.id));
-        const pausas = pausasAbertas(thread, eventos, vivas, quando);
+        const pausas = pausasAbertas(thread, eventos, estados, quando);
         const impedimentos = impedimentosAbertos(item, eventos, item.raiz, quando);
         // O limite de paralelismo da maquina tambem trava, e o escalonador ja o calculou.
         const vaga = item.raiz === carregado.raiz ? vagas.get(thread.id) : undefined;
+        if (vaga && vaga.motivo === 'vaga.stale') {
+            impedimentos.push(parada({
+                natureza: 'impedimento',
+                motivo: 'vaga.stale',
+                fase: thread.faseAtual,
+                bloco: blocoDaFase(thread, thread.faseAtual).bloco,
+                pausaSobre: '',
+                detalhe: vaga.detalhe,
+                evidencia: 'ork board plan (concurrency.stale_after_min)',
+                correcao: vaga.correcao,
+                desdeEm: thread.atualizadaEm,
+                sessaoViva: null,
+                fonte: 'escalonador',
+            }, quando));
+        }
         if (vaga && vaga.motivo === 'concurrency.limite') {
             impedimentos.push(parada({
                 natureza: 'impedimento',
@@ -434,6 +447,7 @@ function montarMonitor(carregado, opcoes = {}) {
             precisaDeHumano,
             temImpedimento: impedimentos.length > 0,
             acimaDoLimite: paradaHaMin !== null && paradaHaMin >= atencaoMin,
+            conducao: (0, conducao_1.conducaoDaThread)(item.raiz, thread.id),
         });
     }
     // Ordem da tabela: quem espera humano primeiro, depois quem tem impedimento, e dentro
@@ -455,7 +469,7 @@ function montarMonitor(carregado, opcoes = {}) {
         projeto: carregado.manifesto.project.name,
         consultadoEm: quando,
         atencaoMin,
-        runtimeConsultado: vivas !== null,
+        runtimeConsultado: estados !== null,
         runtimeDetalhe,
         perfis,
         linhas: visiveis,
@@ -470,15 +484,19 @@ function montarMonitor(carregado, opcoes = {}) {
         },
     };
 }
-/** Uma parada em uma linha, para os blocos de detalhe abaixo da tabela. */
-function linhaDaParada(p) {
+/**
+ * Uma parada em uma linha, para os blocos de detalhe abaixo da tabela. I-35: o dado guarda
+ * ISO (o `--json` e o ledger nao mudam); aqui o horario sai no fuso do dono.
+ */
+function linhaDaParada(p, agora) {
+    const local = (texto) => (0, horario_1.localizarTexto)(texto, { agora });
     const L = [];
-    L.push(`      [${p.motivo}] parada ha ${duracaoCurta(p.paradaHaMin)} (desde ${p.desdeEm.replace('T', ' ').slice(0, 16)})`);
+    L.push(`      [${p.motivo}] parada ha ${(0, horario_1.duracaoRelativa)(p.paradaHaMin)} (desde ${(0, horario_1.formatarHora)(p.desdeEm, { agora })})`);
     if (p.pausaSobre)
         L.push(`      o humano decide: ${p.pausaSobre}`);
-    L.push(`      detalhe  : ${p.detalhe}`);
-    L.push(`      evidencia: ${p.evidencia}`);
-    L.push(`      correcao : ${p.correcao}`);
+    L.push(`      detalhe  : ${local(p.detalhe)}`);
+    L.push(`      evidencia: ${local(p.evidencia)}`);
+    L.push(`      correcao : ${local(p.correcao)}`);
     return L;
 }
 /** Texto de `ork orquestracao status`. */
@@ -490,10 +508,19 @@ function textoDoMonitor(m) {
         `em andamento: ${m.resumo.emAndamento} | podem avancar: ${m.resumo.podemAvancar} | ` +
         `fechadas: ${m.resumo.fechadas}`);
     L.push(`  limite de atencao: ${m.atencaoMin} min (${m.resumo.acimaDoLimite} parada(s) acima, marcadas com !)`);
+    L.push(`  ${(0, horario_1.legendaDoFuso)(undefined, m.consultadoEm)}`);
     if (!m.runtimeConsultado) {
         L.push(`  [warn] ${m.runtimeDetalhe}: pausa prevista e reportada como valendo`);
     }
     L.push('');
+    // I-36 (T17): conducao em andamento nao e parada; ela aparece antes, com a linha unica.
+    const conduzidas = m.linhas.filter((l) => l.conducao);
+    if (conduzidas.length > 0) {
+        L.push('Conduzidas agora:');
+        for (const l of conduzidas)
+            L.push(`  ${l.thread}: ${(0, conducao_texto_1.linhaDeConducao)(l.conducao, { agora: m.consultadoEm })}`);
+        L.push('');
+    }
     if (m.linhas.length === 0) {
         L.push('  Nenhuma thread parada: ninguem esperando veredito humano nem impedido.');
         return L.join('\n');
@@ -519,7 +546,7 @@ function textoDoMonitor(m) {
         l.ultimoEvento ? l.ultimoEvento.tipo : '(sem ledger)',
         l.paradaHaMin === null
             ? '-'
-            : `${duracaoCurta(l.paradaHaMin)}${l.acimaDoLimite ? ' !' : ''}`,
+            : `${(0, horario_1.duracaoRelativa)(l.paradaHaMin)}${l.acimaDoLimite ? ' !' : ''}`,
     ])));
     const hitl = m.linhas.filter((l) => l.precisaDeHumano);
     if (hitl.length > 0) {
@@ -528,7 +555,7 @@ function textoDoMonitor(m) {
         for (const l of hitl) {
             L.push(`  ${l.thread} (${l.tag}, ${l.nome})`);
             for (const p of l.pausas.filter((x) => x.sessaoViva !== true))
-                L.push(...linhaDaParada(p));
+                L.push(...linhaDaParada(p, m.consultadoEm));
         }
     }
     const impedidas = m.linhas.filter((l) => l.temImpedimento);
@@ -538,7 +565,7 @@ function textoDoMonitor(m) {
         for (const l of impedidas) {
             L.push(`  ${l.thread} (${l.tag}, ${l.nome})`);
             for (const p of l.impedimentos)
-                L.push(...linhaDaParada(p));
+                L.push(...linhaDaParada(p, m.consultadoEm));
         }
     }
     const emCurso = m.linhas.filter((l) => l.pausas.some((p) => p.sessaoViva === true));