@orkastery/cli 0.2.0

package/dist/phase.js

@@ -0,0 +1,572 @@
+"use strict";
+/**
+ * `ork phase run|list`: despacho de fase pelo runtime adapter e leitura do ledger.
+ *
+ * O prompt e montado pelo `ork` (nomenclatura das fases + modo de conducao + contexto da
+ * thread + pedido do builder), gravado com hash sha256 no diretorio da thread e so entao
+ * despachado. Depois do despacho o `ork` RE-VERIFICA no runtime que a sessao existe:
+ * self-report de despacho nao vale como evidencia.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGRAS_DE_EVIDENCIA = exports.CONTRATO_DAS_FASES = void 0;
+exports.valoresDoPrompt = valoresDoPrompt;
+exports.montarPrompt = montarPrompt;
+exports.montarPromptComMemoria = montarPromptComMemoria;
+exports.hashDoPrompt = hashDoPrompt;
+exports.slugDaSessao = slugDaSessao;
+exports.resolverDespacho = resolverDespacho;
+exports.dadosDoDespacho = dadosDoDespacho;
+exports.concluirDespacho = concluirDespacho;
+exports.rodarFase = rodarFase;
+exports.tabelaDoLedger = tabelaDoLedger;
+exports.descreverSlug = descreverSlug;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const adapter = __importStar(require("./adapters/claude-bg"));
+const modos_1 = require("./modos");
+const gates_1 = require("./gates");
+const policies_1 = require("./policies");
+const ratelimit_1 = require("./ratelimit");
+const memoria_1 = require("./memoria");
+const prompts_1 = require("./prompts");
+const slug_1 = require("./slug");
+const thread_1 = require("./thread");
+const types_1 = require("./types");
+const util_1 = require("./util");
+const ledger_1 = require("./ledger");
+/** O que cada fase canonica entrega. Vai no cabecalho do prompt de toda sessao. */
+exports.CONTRATO_DAS_FASES = {
+    GOAL: 'GOAL (F1): objetivo verificavel, impact map, criterios de sucesso e claims com comando de verificacao. Nao implementa.',
+    PLAN: 'PLAN (F2): plano com tarefas, touch_paths, decisoes D1..Dn com domicilio unico e verify executavel por tarefa. Nao implementa.',
+    GO: 'GO (F3): implementacao slice por slice, um commit atomico por tarefa, dentro da worktree da thread.',
+    CHECK: 'CHECK (F4): verificacao contra a baseline (regressao versus divida pre-existente), review de codigo, testes, seguranca e performance.',
+    SHIP: 'SHIP (F5): merge serializado, push provado por comando, roadmap atualizado e plano de rollback.',
+    MASTER: 'MASTER (F6): MASTER log com postmortem tipado, licoes e o score humano de 0 a 5. Uma entrega sem MASTER log nao aconteceu.',
+};
+/** As regras de evidencia que valem em toda fase, em todo modo. */
+exports.REGRAS_DE_EVIDENCIA = [
+    'Nada de self-report: toda alegacao vem com o comando que a comprova e a saida real.',
+    'Trabalhe apenas no diretorio de trabalho indicado acima.',
+    'Passos irreversiveis (push, merge, delecao) so acontecem quando o modo autoriza.',
+];
+/**
+ * Os valores que o template de fase recebe.
+ *
+ * Tudo que o prompt diz sai daqui, e nada e calculado dentro do template: template e dado,
+ * decisao e codigo. E o que permite um projeto reescrever o texto do prompt em
+ * `prompts/fase-padrao.md` sem poder mudar o que o `ork` considera verdade.
+ */
+function valoresDoPrompt(thread, fase, pedido, memoriaInjetada = '') {
+    const def = (0, modos_1.definicaoDoModo)(thread.modo);
+    const bloco = (0, thread_1.blocoDaThread)(thread, fase);
+    const pausa = (0, thread_1.pausaNaThread)(thread, fase);
+    return {
+        fase,
+        thread: thread.id,
+        bloco: bloco.fases.join('-'),
+        nome: thread.nome,
+        ciclo_canonico: types_1.FASES.map((f) => `${bloco.fases.includes(f) ? '>' : ' '} ${exports.CONTRATO_DAS_FASES[f]}`).join('\n'),
+        tag: def.tag,
+        blocos: thread.blocos.map((b) => b.fases.join('-')).join(' / '),
+        pausas: String(thread.blocos.filter((b) => b.pausa).length),
+        linha_variante: thread.variante ? `Variante de ciclo: ${thread.variante}` : '',
+        regra_de_pausa: pausa
+            ? `Ao fim deste bloco HA PAUSA humana sobre: ${bloco.pausaSobre}. Pare, apresente a evidencia e espere o veredito.`
+            : 'Ao fim deste bloco NAO ha pausa humana: siga com decisao autonoma e registre no ledger quem decidiu, com que evidencia e por que.',
+        invariantes: modos_1.INVARIANTES.map((i) => `- ${i}`).join('\n'),
+        slug: thread.slug,
+        projeto_nome: thread.projeto.name,
+        projeto_abbrev: thread.projeto.abbrev,
+        base_branch: thread.base.branch,
+        base_commit: thread.base.commit,
+        diretorio: thread.worktree ?? '(raiz do projeto)',
+        pedido: pedido.trim(),
+        // Bloco B6: o bloco de memoria injetada deterministicamente. Vazio em toda thread sem
+        // decisao fechada e sem OrkMind, e ai a linha da variavel some do prompt: o texto fica
+        // byte a byte igual ao que o B4 ja despachava.
+        memoria_injetada: memoriaInjetada,
+        regras_de_evidencia: exports.REGRAS_DE_EVIDENCIA.map((r) => `- ${r}`).join('\n'),
+    };
+}
+/**
+ * Monta o prompt da fase renderizando o template versionado (bloco B4).
+ *
+ * Sem `raiz`, ou sem `prompts/` no projeto, vale o template embutido do `ork`. Com um
+ * `prompts/fase-padrao.md` (ou `prompts/fase-goal.md` e companhia) versionado no repositorio,
+ * vale o do projeto, e `ork prompt lint` e quem garante que ele nao perdeu o contrato.
+ */
+function montarPrompt(thread, fase, pedido, raiz, memoriaInjetada = '') {
+    return (0, prompts_1.renderizar)((0, prompts_1.templateDaFase)(fase, raiz), valoresDoPrompt(thread, fase, pedido, memoriaInjetada));
+}
+/**
+ * Monta o prompt da fase JA com a memoria injetada (bloco B6).
+ *
+ * Separado de `montarPrompt` de proposito: quem so quer renderizar um template (o
+ * `ork prompt render --exemplo`, o lint) nao precisa abrir memoria nenhuma, e quem
+ * despacha uma fase de verdade precisa. Em regime `files` a injecao continua acontecendo,
+ * com as decisoes fechadas lidas do `thread.json`: a garantia nao depende do OrkMind.
+ */
+function montarPromptComMemoria(carregado, thread, fase, pedido, memoria) {
+    const injecao = (0, memoria_1.injecaoDaFase)(carregado, memoria, thread, fase);
+    return {
+        prompt: montarPrompt(thread, fase, pedido, carregado.raiz, injecao.texto),
+        injecao,
+    };
+}
+/** sha256 do prompt, o mesmo hash gravado no `thread.json` e no ledger. */
+function hashDoPrompt(prompt) {
+    return (0, node_crypto_1.createHash)('sha256').update(prompt, 'utf8').digest('hex');
+}
+/** Slug da sessao que conduz esta fase, rotacionando quando o slug ja foi usado na thread. */
+function slugDaSessao(thread, fase) {
+    const bloco = (0, thread_1.blocoDaThread)(thread, fase);
+    const base = (0, slug_1.montarSlug)(thread.projeto.abbrev, thread.assunto, bloco.slugFases);
+    const usados = thread.sessoes.map((s) => s.slug);
+    if (!usados.includes(base))
+        return base;
+    return (0, slug_1.proximaRotacao)(base, usados);
+}
+/**
+ * Modelo e esforco EFETIVAMENTE usados num despacho, resolvidos numa funcao so.
+ *
+ * Regra do esforco: quem informa SO o modelo esta pedindo o despacho mais capaz que
+ * existe, entao o esforco assume `high` em vez de herdar o do manifesto. Quem informa o
+ * esforco manda, e sem nenhum dos dois vale o manifesto. Resolver isso aqui, e nao no
+ * ponto de chamada, e o que permite gravar o par no ledger como FATO: o mesmo valor que
+ * foi para o runtime adapter e o que fica carimbado no evento.
+ */
+function resolverDespacho(manifesto, opcoes) {
+    const model = opcoes.model ?? manifesto.runtime.model;
+    const effort = opcoes.effort ?? (opcoes.model !== undefined ? 'high' : manifesto.runtime.effort);
+    return { model, effort };
+}
+/** O comando com o prompt mascarado pelo hash: o ledger nao guarda o texto inteiro. */
+function comandoMascarado(comando, sha) {
+    return comando.map((c, i) => (i === 2 ? `<prompt:${sha.slice(0, 8)}>` : c));
+}
+/** Os campos que todo evento de despacho carrega, no caminho normal e na retomada. */
+function dadosDoDespacho(ctx, comando) {
+    return {
+        fase: ctx.fase,
+        slug: ctx.slug,
+        modo: ctx.thread.modo,
+        bloco: (0, thread_1.blocoDaThread)(ctx.thread, ctx.fase).fases.join('-'),
+        pausaAoFim: (0, thread_1.pausaNaThread)(ctx.thread, ctx.fase),
+        runtime: ctx.runtime,
+        // Fato verificavel: o modelo e o esforco reais do despacho ficam no proprio evento,
+        // e nao no relato do agente. `ork phase list` le daqui.
+        model: ctx.model,
+        effort: ctx.effort,
+        cwd: ctx.cwd,
+        promptPath: path.relative(ctx.raiz, ctx.promptPath),
+        promptSha256: ctx.promptSha256,
+        origem: ctx.origem,
+        comando: comandoMascarado(comando, ctx.promptSha256),
+    };
+}
+/**
+ * Fecha um despacho BEM SUCEDIDO: ledger, decisao autonoma ou pausa prevista, e a
+ * sessao gravada no `thread.json`. Usada pelo `ork phase run` e pela retomada do B3.
+ */
+function concluirDespacho(ctx, sessionId, verificada, comando) {
+    const dir = (0, thread_1.dirThread)(ctx.raiz, ctx.thread.id);
+    const comum = dadosDoDespacho(ctx, comando);
+    const bloco = (0, thread_1.blocoDaThread)(ctx.thread, ctx.fase);
+    const pausaAoFim = (0, thread_1.pausaNaThread)(ctx.thread, ctx.fase);
+    (0, ledger_1.registrar)(dir, ctx.thread.id, ledger_1.TIPOS_DE_EVENTO.faseDespachada, { ...comum, sessionId });
+    (0, ledger_1.registrar)(dir, ctx.thread.id, ledger_1.TIPOS_DE_EVENTO.despachoVerificado, {
+        fase: ctx.fase,
+        slug: ctx.slug,
+        sessionId,
+        fonte: 'claude agents --json',
+        encontrada: verificada,
+    });
+    if (!pausaAoFim) {
+        (0, ledger_1.registrar)(dir, ctx.thread.id, ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma, {
+            fase: ctx.fase,
+            slug: ctx.slug,
+            sessionId,
+            decisao: `bloco ${bloco.fases.join('-')} segue sem pausa humana`,
+            autorizadoPor: `#TAG ${(0, modos_1.definicaoDoModo)(ctx.thread.modo).tag} no pedido do builder`,
+            evidencia: `prompt sha256 ${ctx.promptSha256}`,
+        });
+    }
+    else {
+        (0, ledger_1.registrar)(dir, ctx.thread.id, ledger_1.TIPOS_DE_EVENTO.pausaHumana, {
+            fase: ctx.fase,
+            slug: ctx.slug,
+            sessionId,
+            previstaSobre: bloco.pausaSobre,
+            estado: 'prevista ao fim do bloco',
+        });
+    }
+    const sessao = {
+        slug: ctx.slug,
+        fase: ctx.fase,
+        bloco: bloco.fases.join('-'),
+        sessionId,
+        runtime: ctx.runtime,
+        despachadaEm: (0, util_1.agora)(),
+        promptPath: path.relative(ctx.raiz, ctx.promptPath),
+        promptSha256: ctx.promptSha256,
+        verificada,
+    };
+    ctx.thread.sessoes.push(sessao);
+    ctx.thread.faseAtual = ctx.fase;
+    (0, thread_1.gravarThread)(ctx.raiz, ctx.thread);
+    return sessao;
+}
+/** Despacha a fase pelo runtime adapter e registra tudo no ledger da thread. */
+function rodarFase(carregado, threadId, opcoes) {
+    const { raiz, manifesto } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    const fase = opcoes.fase;
+    const dir = (0, thread_1.dirThread)(raiz, thread.id);
+    const slug = slugDaSessao(thread, fase);
+    // Resolve UMA vez o par modelo/esforco: o mesmo objeto vai ao runtime adapter, ao
+    // ledger e a resposta do CLI. Resolver duas vezes e o caminho curto para o ledger
+    // dizer um modelo e o `claude --bg` receber outro.
+    const { model, effort } = resolverDespacho(manifesto, opcoes);
+    // Bloco B6: a memoria entra ANTES do hash. O prompt que o ledger carimba e o mesmo que
+    // o agente recebe, memoria injetada inclusa.
+    const memoria = opcoes.memoria ?? (0, memoria_1.abrirMemoria)(carregado);
+    const { prompt, injecao } = montarPromptComMemoria(carregado, thread, fase, opcoes.prompt, memoria);
+    const sha = hashDoPrompt(prompt);
+    const promptPath = path.join(dir, 'prompts', `${slug}-${fase.toLowerCase()}-${sha.slice(0, 8)}.md`);
+    // Gate tipado do bloco B1: as policies do manifesto valem ANTES do despacho, em
+    // qualquer modo. Prompt reprovado nem chega a ser gravado em disco: gravar um prompt
+    // com credencial e criar um segundo vazamento no proprio repositorio.
+    const violacoes = (0, policies_1.avaliarPolicies)(manifesto, { gate: 'phase.dispatch', prompt });
+    const bloqueiam = (0, policies_1.bloqueantes)(violacoes);
+    if (bloqueiam.length > 0) {
+        const detalhe = bloqueiam.map((v) => `${v.policy}: ${v.detalhe}`).join('; ');
+        // Bloco B3: violacao de CUSTO sai tipada como tal. E o que permite a politica de
+        // retry recusar reexecucao automatica dela sem reabrir o nome da policy aqui.
+        const motivoDoLote = (0, policies_1.motivoDominante)(bloqueiam);
+        (0, gates_1.registrarGateBloqueado)(dir, thread.id, {
+            gate: 'phase.dispatch',
+            motivo: motivoDoLote,
+            modo: thread.modo,
+            detalhe,
+            correcao: bloqueiam.map((v) => v.correcao).join('; '),
+            fase,
+            slug,
+            evidencia: `prompt sha256 ${sha} (nao gravado em disco)`,
+        });
+        return {
+            thread,
+            slug,
+            promptPath,
+            promptSha256: sha,
+            comando: [],
+            sessionId: null,
+            verificada: false,
+            pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase),
+            dryRun: opcoes.dryRun === true,
+            model,
+            effort,
+            bloqueado: true,
+            motivo: motivoDoLote,
+            violacoes,
+            erro: detalhe,
+        };
+    }
+    (0, util_1.gravar)(promptPath, prompt);
+    // A injecao e evidencia: o ledger diz quantos itens entraram, de que colecao e de onde,
+    // para que "o prompt tinha a decisao D2" seja verificavel depois sem reler o prompt.
+    if (injecao.itens.length > 0) {
+        (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.memoriaInjetada, {
+            fase,
+            slug,
+            regime: injecao.regime,
+            decisoes: injecao.decisoes,
+            licoes: injecao.licoes,
+            regras: injecao.regras,
+            itens: injecao.itens.map((i) => `${i.id}:${i.colecao}:${i.location}`),
+            promptSha256: sha,
+        });
+    }
+    if (memoria.estado.motivo && memoria.estado.pedido === 'orkmind') {
+        (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.memoriaDegradada, {
+            fase,
+            slug,
+            pedido: memoria.estado.pedido,
+            efetivo: memoria.estado.efetivo,
+            motivo: memoria.estado.motivo,
+            detalhe: memoria.estado.detalhe,
+            correcao: memoria.estado.correcao,
+        });
+    }
+    const cwd = thread.worktree ?? raiz;
+    const pausaAoFim = (0, thread_1.pausaNaThread)(thread, fase);
+    const resultado = adapter.despachar({
+        prompt,
+        nome: slug,
+        cwd,
+        model,
+        effort,
+        dryRun: opcoes.dryRun,
+    });
+    const ctx = {
+        raiz,
+        thread,
+        fase,
+        slug,
+        promptPath,
+        promptSha256: sha,
+        runtime: manifesto.runtime.adapter,
+        cwd,
+        model,
+        effort,
+        origem: 'phase.run',
+    };
+    const comum = dadosDoDespacho(ctx, resultado.comando);
+    if (opcoes.dryRun) {
+        return {
+            thread,
+            slug,
+            promptPath,
+            promptSha256: sha,
+            comando: resultado.comando,
+            sessionId: null,
+            verificada: false,
+            pausaAoFim,
+            dryRun: true,
+            // O ensaio NAO toca no ledger (a garantia do B0 continua de pe), mas devolve o
+            // par resolvido: e assim que o `--dry-run` mostra o modelo que seria despachado.
+            model,
+            effort,
+            bloqueado: false,
+            motivo: null,
+            violacoes,
+        };
+    }
+    if (!resultado.ok || !resultado.sessionId) {
+        const erro = resultado.erro ?? 'sem sessionId na saida do runtime';
+        (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.despachoFalhou, {
+            ...comum,
+            erro,
+            stderr: resultado.stderr.slice(0, 500),
+        });
+        // Bloco B3: rate limit nao e falha seca. A fase morreu com HORA de volta, entao ela
+        // vira pedido na fila duravel em vez de virar tarefa da memoria de alguem. O prompt
+        // ja esta gravado em disco com o sha256 acima, e e ele que sera redespachado.
+        const sinal = resultado.rateLimit ?? null;
+        if (sinal) {
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.rateLimitDetectado, {
+                fase,
+                slug,
+                fonte: sinal.fonte,
+                resetEm: sinal.resetEm,
+                trecho: sinal.trecho,
+                evidencia: 'stderr real do runtime adapter, nao relato do agente',
+            });
+            const pedido = (0, ratelimit_1.enfileirar)(carregado, {
+                thread: thread.id,
+                fase,
+                slug,
+                promptPath,
+                promptSha256: sha,
+                cwd,
+                model,
+                effort,
+                sinal,
+                detalhe: erro,
+            });
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.rateLimitEnfileirado, {
+                fase,
+                slug,
+                pedido: pedido.id,
+                liberaEm: pedido.liberaEm,
+                janelaEstimada: pedido.janelaEstimada,
+                fonte: sinal.fonte,
+                promptSha256: sha,
+                correcao: `ork retry resume (ou aguarde ate ${pedido.liberaEm})`,
+            });
+            return {
+                thread,
+                slug,
+                promptPath,
+                promptSha256: sha,
+                comando: resultado.comando,
+                sessionId: null,
+                verificada: false,
+                pausaAoFim,
+                dryRun: false,
+                model,
+                effort,
+                bloqueado: false,
+                motivo: 'runtime.rate-limited',
+                violacoes,
+                naFila: pedido,
+                erro,
+            };
+        }
+        return {
+            thread,
+            slug,
+            promptPath,
+            promptSha256: sha,
+            comando: resultado.comando,
+            sessionId: null,
+            verificada: false,
+            pausaAoFim,
+            dryRun: false,
+            model,
+            effort,
+            bloqueado: false,
+            motivo: 'runtime.unavailable',
+            violacoes,
+            naFila: null,
+            erro,
+        };
+    }
+    concluirDespacho(ctx, resultado.sessionId, resultado.verificada, resultado.comando);
+    return {
+        thread,
+        slug,
+        promptPath,
+        promptSha256: sha,
+        comando: resultado.comando,
+        sessionId: resultado.sessionId,
+        verificada: resultado.verificada,
+        pausaAoFim,
+        dryRun: false,
+        model,
+        effort,
+        bloqueado: false,
+        motivo: null,
+        violacoes,
+    };
+}
+/** Tabela de `ork phase list`: o historico do ledger da thread. */
+function tabelaDoLedger(raiz, threadId) {
+    // Thread inexistente e erro, nao ledger vazio: o CLI precisa reprovar o id errado.
+    (0, thread_1.lerThread)(raiz, threadId);
+    const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId));
+    if (eventos.length === 0) {
+        return `Ledger vazio para a thread ${threadId}.`;
+    }
+    const linhas = eventos.map((e) => {
+        const detalhe = [];
+        if (e.fase)
+            detalhe.push(String(e.fase));
+        if (e.slug)
+            detalhe.push(String(e.slug));
+        if (e.sessionId)
+            detalhe.push(`sessao ${String(e.sessionId).slice(0, 8)}`);
+        if (e.decisao)
+            detalhe.push(String(e.decisao));
+        if (e.previstaSobre)
+            detalhe.push(`pausa sobre ${String(e.previstaSobre)}`);
+        if (e.encontrada !== undefined)
+            detalhe.push(`no runtime: ${e.encontrada ? 'sim' : 'nao'}`);
+        // Fato verificavel do despacho: o par modelo/esforco real, lido do proprio evento.
+        if (e.model)
+            detalhe.push(`modelo ${String(e.model)}/${String(e.effort ?? '-')}`);
+        // Eventos do bloco B1: motivo tipado, veredito e as provas do ship.
+        if (e.motivo)
+            detalhe.push(`motivo ${String(e.motivo)}`);
+        if (e.claim)
+            detalhe.push(`claim ${String(e.claim)}`);
+        if (e.veredito)
+            detalhe.push(`veredito: ${String(e.veredito)}`);
+        if (e.fonte && e.ocupacao !== undefined) {
+            detalhe.push(`ocupacao ${e.ocupacao === null ? 'nao medivel' : String(e.ocupacao)} (${String(e.fonte)})`);
+        }
+        if (e.slugSugerido)
+            detalhe.push(`proximo slug ${String(e.slugSugerido)}`);
+        if (e.lease)
+            detalhe.push(`lease ${String(e.lease)}`);
+        // Eventos do bloco B3: acao de retry, playbook da retomada e rodada de GO-FIX.
+        if (e.acao)
+            detalhe.push(`acao ${String(e.acao)}`);
+        if (e.playbook)
+            detalhe.push(`playbook ${String(e.playbook)}`);
+        if (e.pedido)
+            detalhe.push(`pedido ${String(e.pedido)}`);
+        if (e.rodada !== undefined)
+            detalhe.push(`rodada ${String(e.rodada)}`);
+        if (e.cobertura)
+            detalhe.push(`cobertura ${String(e.cobertura)}`);
+        if (e.liberaEm)
+            detalhe.push(`libera em ${String(e.liberaEm)}`);
+        if (e.tentativa !== undefined && e.limite !== undefined) {
+            detalhe.push(`tentativa ${String(e.tentativa)}/${String(e.limite)}`);
+        }
+        if (e.mergeSha)
+            detalhe.push(`merge ${String(e.mergeSha).slice(0, 8)}`);
+        if (e.shaRemoto)
+            detalhe.push(`remoto ${String(e.shaRemoto).slice(0, 8)}`);
+        if (e.pushVerificado !== undefined)
+            detalhe.push(`push provado: ${e.pushVerificado ? 'sim' : 'nao'}`);
+        if (e.autorizadoPor)
+            detalhe.push(`autorizado por ${String(e.autorizadoPor)}`);
+        if (e.sobre)
+            detalhe.push(`sobre ${String(e.sobre)}`);
+        if (e.estado)
+            detalhe.push(String(e.estado));
+        if (typeof e.de === 'string' && typeof e.para === 'string') {
+            detalhe.push(`${e.de} -> ${e.para}`);
+        }
+        if (e.dryRun === true)
+            detalhe.push('ensaio (--dry-run)');
+        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.worktreeCriada && e.dir) {
+            detalhe.push(`${String(e.branch)} em ${String(e.dir)}`);
+        }
+        if (e.inline !== undefined) {
+            detalhe.push(`triagem ${String(e.inline)} inline / ${String(e.pointers)} ponteiros / ${String(e.summaries)} resumos`);
+        }
+        if (e.location)
+            detalhe.push(`ponteiro ${String(e.location)}`);
+        if (e.erro)
+            detalhe.push(`erro: ${String(e.erro)}`);
+        if (e.detalhe && !e.decisao)
+            detalhe.push(String(e.detalhe).slice(0, 90));
+        if (e.modo && !e.fase)
+            detalhe.push(`modo ${String(e.modo)}`);
+        return [e.ts.replace('T', ' ').slice(0, 19), e.tipo, detalhe.join(' | ')];
+    });
+    return (0, util_1.tabela)(['QUANDO', 'EVENTO', 'DETALHE'], linhas);
+}
+/** Slug legivel por humano de uma sessao (usado nas mensagens do CLI). */
+function descreverSlug(slug) {
+    const p = (0, slug_1.parseSlug)(slug);
+    if (!p)
+        return slug;
+    const rot = p.rotacao ? `, rotacao ${p.rotacao}` : '';
+    return `produto "${p.produto}", assunto "${p.assunto}", fases "${p.fases}"${rot}`;
+}