@orkastery/cli 0.5.6 → 0.6.1

package/dist/noctum-medicao.js

@@ -0,0 +1,450 @@
+"use strict";
+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.TETO_DO_ARQUIVO_MEDIDO = exports.UNIDADES_MEDIDAS = exports.CONTRATO_MEDICAO = void 0;
+exports.fontesDoDisco = fontesDoDisco;
+exports.tokensDasTranscricoes = tokensDasTranscricoes;
+exports.leituraDoRollout = leituraDoRollout;
+exports.cotaDasLeituras = cotaDasLeituras;
+exports.medirArco = medirArco;
+exports.consumoDoEscopoNaUnidade = consumoDoEscopoNaUnidade;
+exports.precisaMedir = precisaMedir;
+exports.medidoParaReserva = medidoParaReserva;
+exports.textoDoConsumo = textoDoConsumo;
+/**
+ * RM-058, fatia N6 (D4, D5 e D9 da ork-rm058n6): a medição do consumo do arco nas unidades do orçamento.
+ *
+ * A N2 mediu só `sessoes` (as reservas não recusadas). Aqui entram as outras três, sempre a partir do que o núcleo e o
+ * runtime gravaram, nunca de estimativa:
+ *
+ *  - `minutos-de-sessao`: do `phase_dispatch` da sessão ao primeiro resultado dela no ledger da thread (`phase_result`,
+ *    `sessao_morta` ou `session_superseded`), arredondado para cima por sessão. A latência do observador fica dentro:
+ *    a medida é sempre a maior. A sessão em voo conta até o instante da leitura e sai marcada como parcial.
+ *  - `tokens`: o que o runtime diz ter processado, sem conversão. No Claude Code, o `message.usage` da transcrição da
+ *    sessão e dos subagentes, uma vez por `message.id` (a transcrição repete o mesmo uso em cada bloco da resposta):
+ *    entrada, criação de cache, leitura de cache e saída. No codex, o `total_tokens` do último `token_count` do rollout.
+ *  - `percentual-da-cota`: só o codex grava a cota fora da sessão (`rate_limits` do rollout). O valor é o `used_percent`
+ *    mais alto da janela, que inclui o uso de antes do arco e o de outros projetos na mesma janela: teto superior, nunca
+ *    menos que o consumo real. Janela que renovou no meio do arco perde o uso de antes da renovação, e vira lacuna. O
+ *    Claude Code só mostra a cota aos mods dentro da sessão: conta claude-bg em percentual é sempre lacuna.
+ *
+ * Consumo desconhecido nunca é zero: reserva pendente (a sessão pode ter aberto sem id), ledger ilegível, transcrição ou
+ * rollout ausente, linha ilegível no meio do arquivo e sessão sem leitura ainda viram lacuna tipada, e a lacuna de uma
+ * sessão contamina o escopo inteiro dela. Zero só é medido quando nenhuma sessão do arco caiu no escopo.
+ *
+ * Nada aqui grava. `fontes` é dependência dos testes; em produção, o ledger, o store de perfis, a transcrição e o rollout.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const codex_1 = require("./adapters/codex");
+const ledger_1 = require("./ledger");
+const noctum_envelope_1 = require("./noctum-envelope");
+const runtime_profiles_1 = require("./runtime-profiles");
+const session_watcher_claude_1 = require("./session-watcher-claude");
+const thread_1 = require("./thread");
+exports.CONTRATO_MEDICAO = 'ork.noctum-medicao/v1';
+exports.UNIDADES_MEDIDAS = ['minutos-de-sessao', 'tokens', 'percentual-da-cota'];
+/** Arquivo de transcrição ou rollout acima disto não é lido inteiro: vira lacuna, nunca leitura parcial. */
+exports.TETO_DO_ARQUIVO_MEDIDO = 256 * 1024 * 1024;
+/** Duas leituras da mesma janela com renovações a menos disto são a mesma janela (o arredondamento do runtime). */
+const TOLERANCIA_DA_RENOVACAO_MS = 120_000;
+function lerArquivoLimitado(arquivo) {
+    let fd;
+    try {
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch {
+        return null;
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.size > exports.TETO_DO_ARQUIVO_MEDIDO)
+            return null;
+        return fs.readFileSync(fd);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** As fontes de produção para a raiz de estado dada. */
+function fontesDoDisco(raiz) {
+    let perfis;
+    return {
+        eventos: (thread) => { try {
+            return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread));
+        }
+        catch {
+            return null;
+        } },
+        cwd: (thread) => { try {
+            return (0, thread_1.lerThread)(raiz, thread).worktree ?? null;
+        }
+        catch {
+            return null;
+        } },
+        perfil: (conta) => {
+            if (perfis === undefined) {
+                try {
+                    perfis = (0, runtime_profiles_1.lerPerfis)(raiz);
+                }
+                catch {
+                    perfis = null;
+                }
+            }
+            if (perfis === null)
+                return undefined;
+            const p = perfis.perfis.find(x => x.id === conta);
+            return p ? (0, runtime_profiles_1.perfilDeDespacho)(p) : null;
+        },
+        transcricoes: (perfil, cwd, sessionId) => {
+            const principal = (0, session_watcher_claude_1.arquivoDaTranscricao)(perfil, cwd, sessionId);
+            if (!principal)
+                return null;
+            try {
+                if (!fs.lstatSync(principal).isFile())
+                    return null;
+            }
+            catch {
+                return null;
+            }
+            const dir = path.join(path.dirname(principal), sessionId, 'subagents');
+            let subagentes = [];
+            try {
+                subagentes = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl')).sort().map(f => path.join(dir, f));
+            }
+            catch {
+                subagentes = [];
+            }
+            return [principal, ...subagentes];
+        },
+        rollout: (perfil, sessionId) => { try {
+            return (0, codex_1.acharRollout)(sessionId, 3, (0, codex_1.casaDoCodex)(perfil));
+        }
+        catch {
+            return null;
+        } },
+        ler: lerArquivoLimitado,
+    };
+}
+/** O primeiro destes eventos da sessão no ledger da thread é o fim dela. */
+const FIM_DA_SESSAO = ['phase_result', 'sessao_morta', 'session_superseded'];
+const numero = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
+/** As linhas JSON de um arquivo de acréscimo; a última sem quebra está sendo gravada e fica de fora. */
+function linhasJson(bruto) {
+    const fim = bruto.lastIndexOf(0x0a) + 1;
+    const textos = bruto.subarray(0, fim).toString('utf8').split('\n').slice(0, -1);
+    const linhas = [];
+    let ilegivel = 0;
+    for (const t of textos) {
+        if (!t.trim())
+            continue;
+        try {
+            linhas.push(JSON.parse(t));
+        }
+        catch {
+            ilegivel += 1;
+        }
+    }
+    return { linhas, ilegivel };
+}
+/**
+ * Os tokens das transcrições do Claude Code: um uso por `message.id`, somando entrada, criação de cache, leitura de
+ * cache e saída. Linha ilegível no meio (não a cauda em gravação) é lacuna: ela poderia esconder uso.
+ */
+function tokensDasTranscricoes(conteudos) {
+    const vistos = new Set();
+    let total = 0;
+    for (const bruto of conteudos) {
+        const lido = linhasJson(bruto);
+        if (!lido)
+            return { lacuna: 'transcrição ilegível' };
+        if (lido.ilegivel)
+            return { lacuna: `transcrição com ${lido.ilegivel} linha(s) ilegível(is) no meio` };
+        for (const l of lido.linhas) {
+            const e = l;
+            if (e?.type !== 'assistant' || !e.message || typeof e.message !== 'object' || !e.message.usage)
+                continue;
+            const u = e.message.usage;
+            const partes = [u.input_tokens, u.cache_creation_input_tokens ?? 0, u.cache_read_input_tokens ?? 0, u.output_tokens];
+            if (!partes.every(numero))
+                return { lacuna: 'transcrição com uso de tokens fora do formato' };
+            // Sem id, a linha conta sozinha: duplicar superestima, nunca subestima.
+            const chave = typeof e.message.id === 'string' && e.message.id ? e.message.id : `linha:${vistos.size}:${String(e.uuid)}`;
+            if (vistos.has(chave))
+                continue;
+            vistos.add(chave);
+            total += partes.reduce((a, b) => a + b, 0);
+        }
+    }
+    return { valor: total, parcial: false, tetoSuperior: false, fonte: 'message.usage da transcrição do Claude Code' };
+}
+/** Os tokens e as leituras da cota do rollout do codex: o último `token_count` e cada `rate_limits` dele. */
+function leituraDoRollout(bruto) {
+    const lido = linhasJson(bruto);
+    if (!lido || lido.ilegivel)
+        return { tokens: { lacuna: 'rollout com linha ilegível no meio' }, cota: { lacuna: 'rollout com linha ilegível no meio' } };
+    let total = null;
+    const cota = [];
+    for (const l of lido.linhas) {
+        const e = l;
+        const p = e?.type === 'event_msg' ? e.payload : e;
+        if (!p || p.type !== 'token_count')
+            continue;
+        const info = p.info;
+        const uso = info?.total_token_usage;
+        if (uso && typeof uso === 'object') {
+            const t = uso.total_tokens ?? (numero(uso.input_tokens) && numero(uso.output_tokens) ? Number(uso.input_tokens) + Number(uso.output_tokens) : undefined);
+            if (numero(t))
+                total = t;
+        }
+        const limites = p.rate_limits;
+        const lidaEm = typeof e.timestamp === 'string' && Number.isFinite(Date.parse(e.timestamp)) ? new Date(Date.parse(e.timestamp)).toISOString() : null;
+        if (!limites || typeof limites !== 'object' || !lidaEm)
+            continue;
+        for (const nome of ['primary', 'secondary']) {
+            const j = limites[nome];
+            if (!j || typeof j !== 'object' || !numero(j.used_percent) || !numero(j.window_minutes))
+                continue;
+            const renovaEm = numero(j.resets_at) ? Number(j.resets_at) * 1000
+                : numero(j.resets_in_seconds) ? Date.parse(lidaEm) + Number(j.resets_in_seconds) * 1000 : null;
+            cota.push({ janelaMin: Number(j.window_minutes), usado: Number(j.used_percent), renovaEm, lidaEm });
+        }
+    }
+    return { tokens: total === null ? { lacuna: 'rollout sem contagem de tokens ainda' }
+            : { valor: total, parcial: false, tetoSuperior: false, fonte: 'token_count do rollout do codex' }, cota };
+}
+/**
+ * A cota do codex de uma conta pelas leituras das sessões do arco: o `used_percent` mais alto de cada janela, e a janela
+ * que mais subiu manda. A janela que renovou entre leituras é lacuna (o uso de antes da renovação não se prova).
+ */
+function cotaDasLeituras(leituras) {
+    if (!leituras.length)
+        return { lacuna: 'nenhuma leitura da cota no rollout das sessões do arco' };
+    let maior = 0;
+    const porJanela = new Map();
+    for (const l of leituras)
+        porJanela.set(l.janelaMin, [...(porJanela.get(l.janelaMin) ?? []), l]);
+    for (const [janela, lista] of porJanela) {
+        const renovacoes = lista.map(l => l.renovaEm).filter((x) => x !== null);
+        if (renovacoes.length && Math.max(...renovacoes) - Math.min(...renovacoes) > TOLERANCIA_DA_RENOVACAO_MS) {
+            return { lacuna: `a janela de ${janela} min renovou no meio do arco; o uso de antes da renovação não se prova` };
+        }
+        maior = Math.max(maior, ...lista.map(l => l.usado));
+    }
+    return { valor: maior, parcial: false, tetoSuperior: true,
+        fonte: 'rate_limits do rollout do codex (inclui o uso de antes do arco e de outros projetos na janela)' };
+}
+function medirSessao(d, quando, fontes) {
+    const base = { seq: d.seq, trabalho: d.trabalho, thread: d.threadDespachada ?? d.thread, sessionId: d.sessionId, runtime: d.runtime,
+        conta: d.conta, inicio: null, fim: null, emVoo: false };
+    const lacuna = (motivo) => ({ ...base, emVoo: true, minutos: { lacuna: motivo }, tokens: { lacuna: motivo },
+        cota: { lacuna: motivo } });
+    if (d.desfecho === 'pendente')
+        return lacuna('reserva pendente: a sessão pode ter aberto sem id, e o consumo fica desconhecido até a reconciliação');
+    if (!d.sessionId || !base.thread) {
+        // O despacho idempotente sem sessão nova não abriu nada: zero provado para esta reserva.
+        const zero = { valor: 0, parcial: false, tetoSuperior: false, fonte: 'despacho idempotente: a sessão em curso já atendia' };
+        return { ...base, minutos: zero, tokens: zero, cota: [] };
+    }
+    const thread = base.thread, sessionId = d.sessionId;
+    const eventos = fontes.eventos(thread);
+    if (eventos === null)
+        return lacuna(`o ledger da thread ${thread} não se lê`);
+    const inicio = eventos.find(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada && e.sessionId === sessionId)?.ts ?? null;
+    const fim = inicio ? eventos.find(e => FIM_DA_SESSAO.includes(e.tipo) && e.sessionId === sessionId && e.ts >= inicio)?.ts ?? null : null;
+    const emVoo = fim === null;
+    const duracao = inicio ? Math.ceil((Date.parse(fim ?? quando) - Date.parse(inicio)) / 60_000) : Number.NaN;
+    const minutos = !inicio ? { lacuna: `sem o phase_dispatch da sessão ${sessionId} no ledger da thread ${thread}` }
+        // Instante que não é data (linha emendada à mão) não vira NaN abaixo do teto: é lacuna.
+        : !Number.isFinite(duracao) ? { lacuna: `instante ilegível no ledger da thread ${thread} para a sessão ${sessionId}` }
+            : { valor: Math.max(0, duracao), parcial: emVoo, tetoSuperior: false,
+                fonte: emVoo ? 'do phase_dispatch até a leitura (sessão em voo)' : 'do phase_dispatch ao resultado gravado no ledger' };
+    const perfil = fontes.perfil(d.conta);
+    let tokens;
+    let cota;
+    if (perfil === undefined) {
+        tokens = { lacuna: 'o store de perfis não se lê' };
+        cota = { lacuna: 'o store de perfis não se lê' };
+    }
+    else if (d.runtime === 'claude-bg') {
+        cota = { lacuna: 'o Claude Code só mostra a cota aos mods dentro da sessão, fora do alcance do núcleo' };
+        const cwd = fontes.cwd(thread);
+        const arquivos = cwd ? fontes.transcricoes(perfil, cwd, sessionId) : null;
+        if (!cwd)
+            tokens = { lacuna: `a thread ${thread} não diz onde a sessão rodou` };
+        else if (!arquivos)
+            tokens = { lacuna: `sem a transcrição da sessão ${sessionId}` };
+        else {
+            // Um arquivo por vez na memória: a sessão com muitos subagentes não junta todas as transcrições de uma vez.
+            let ilegivel = false;
+            const lidas = function* () {
+                for (const a of arquivos) {
+                    const c = fontes.ler(a);
+                    if (c === null) {
+                        ilegivel = true;
+                        return;
+                    }
+                    yield c;
+                }
+            };
+            const medida = tokensDasTranscricoes(lidas());
+            tokens = ilegivel ? { lacuna: 'transcrição que não se lê' } : medida;
+        }
+    }
+    else if (d.runtime === 'codex') {
+        const arquivo = fontes.rollout(perfil, sessionId);
+        const bruto = arquivo ? fontes.ler(arquivo) : null;
+        if (!bruto) {
+            tokens = { lacuna: `sem o rollout da sessão ${sessionId}` };
+            cota = { lacuna: `sem o rollout da sessão ${sessionId}` };
+        }
+        else {
+            const r = leituraDoRollout(bruto);
+            tokens = r.tokens;
+            cota = r.cota;
+        }
+    }
+    else {
+        tokens = { lacuna: `runtime ${d.runtime} sem fonte de medição` };
+        cota = { lacuna: `runtime ${d.runtime} sem fonte de medição` };
+    }
+    if ('valor' in tokens)
+        tokens = { ...tokens, parcial: emVoo };
+    return { ...base, inicio, fim, emVoo, minutos, tokens, cota };
+}
+function vazio(unidade) {
+    return { unidade, valor: 0, lacunas: [], parcial: false, tetoSuperior: false, sessoes: 0 };
+}
+function somar(alvo, m, origem) {
+    alvo.sessoes += 1;
+    if ('lacuna' in m || !Number.isFinite(m.valor)) {
+        alvo.lacunas.push(`${origem}: ${'lacuna' in m ? m.lacuna : 'medida que não é número'}`);
+        alvo.valor = null;
+        return;
+    }
+    if (alvo.valor !== null)
+        alvo.valor += m.valor;
+    alvo.parcial = alvo.parcial || m.parcial;
+    alvo.tetoSuperior = alvo.tetoSuperior || m.tetoSuperior;
+}
+/** As sessões do escopo, somadas em cada unidade; a cota é somada por conta (cada conta com a medida da cota dela). */
+function consumoDoEscopo(sessoes, sessoesNaUnidade) {
+    const r = Object.fromEntries(noctum_envelope_1.UNIDADES.map(u => [u, vazio(u)]));
+    r.sessoes.valor = sessoesNaUnidade;
+    r.sessoes.sessoes = sessoesNaUnidade;
+    for (const s of sessoes) {
+        const origem = `sessão ${s.sessionId ?? `da reserva ${s.seq}`} (${s.trabalho})`;
+        somar(r['minutos-de-sessao'], s.minutos, origem);
+        somar(r.tokens, s.tokens, origem);
+    }
+    for (const conta of [...new Set(sessoes.map(s => s.conta))].sort()) {
+        const daConta = sessoes.filter(s => s.conta === conta);
+        const comLacuna = daConta.find(s => !Array.isArray(s.cota));
+        const medida = comLacuna ? { lacuna: comLacuna.cota.lacuna }
+            : cotaDasLeituras(daConta.flatMap(s => s.cota));
+        somar(r['percentual-da-cota'], medida, `conta ${conta}`);
+    }
+    r['percentual-da-cota'].sessoes = sessoes.length;
+    return r;
+}
+/** Mede o consumo do arco no instante dado. Sem gravar nada; a sessão repetida (o mesmo id) conta uma vez. */
+function medirArco(raiz, estado, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const base = { ...fontesDoDisco(raiz), ...opcoes.fontes };
+    // O ledger de cada thread é lido uma vez por medição, e não uma vez por sessão.
+    const ledgers = new Map();
+    const fontes = { ...base, eventos: (thread) => {
+            if (!ledgers.has(thread))
+                ledgers.set(thread, base.eventos(thread));
+            return ledgers.get(thread);
+        } };
+    const vistas = new Set();
+    const sessoes = [];
+    for (const d of estado.despachos) {
+        if (d.desfecho === 'recusado')
+            continue;
+        if (d.sessionId) {
+            if (vistas.has(d.sessionId))
+                continue;
+            vistas.add(d.sessionId);
+        }
+        sessoes.push(medirSessao(d, quando, fontes));
+    }
+    const contas = [...new Set(sessoes.map(s => s.conta))].sort(), runtimes = [...new Set(sessoes.map(s => s.runtime))].sort();
+    return {
+        contrato: exports.CONTRATO_MEDICAO, arco: estado.arco, quando, sessoes,
+        doArco: consumoDoEscopo(sessoes, estado.consumo.arco),
+        porConta: Object.fromEntries(contas.map(c => [c, consumoDoEscopo(sessoes.filter(s => s.conta === c), estado.consumo.porConta[c] ?? 0)])),
+        porRuntime: Object.fromEntries(runtimes.map(r => [r, consumoDoEscopo(sessoes.filter(s => s.runtime === r), estado.consumo.porRuntime[r] ?? 0)])),
+    };
+}
+/** O consumo de um escopo numa unidade; escopo sem sessão do arco mede zero (provado: nenhuma sessão caiu nele). */
+function consumoDoEscopoNaUnidade(medicao, escopo, unidade) {
+    const porUnidade = escopo === 'arco' ? medicao.doArco : 'conta' in escopo ? medicao.porConta[escopo.conta] : medicao.porRuntime[escopo.runtime];
+    return porUnidade?.[unidade] ?? vazio(unidade);
+}
+/** Algum teto do envelope está numa unidade que não é `sessoes`? Só então o passo precisa medir. */
+function precisaMedir(conteudo) {
+    const o = conteudo.orcamento;
+    return [o.arco, ...o.porConta.map(s => s.teto), ...o.porRuntime.map(s => s.teto)].some(t => t.unidade !== 'sessoes');
+}
+const valorMedido = (c) => c.valor === null
+    ? { unidade: c.unidade, lacuna: c.lacunas.join('; ') || 'consumo desconhecido' }
+    : { unidade: c.unidade, valor: c.valor, ...(c.tetoSuperior ? { tetoSuperior: true } : {}) };
+/** O consumo medido dos três tetos de um despacho (arco, conta e runtime), cada um na unidade dele. */
+function medidoParaReserva(medicao, conteudo, conta, runtime) {
+    const o = conteudo.orcamento;
+    const daConta = o.porConta.find(s => s.conta === conta)?.teto, doRuntime = o.porRuntime.find(s => s.runtime === runtime)?.teto;
+    // A sessão do claude-bg nunca terá a cota medida fora dela: o teto em percentual não se garante para ela, nem com o
+    // zero provado de um escopo ainda sem sessão (runtime sem medição suficiente não é elegível para o regime).
+    const medido = (c) => c.unidade === 'percentual-da-cota' && runtime === 'claude-bg'
+        ? { unidade: c.unidade, lacuna: 'o Claude Code só mostra a cota dentro da sessão, e o teto em percentual não se garante para ele' }
+        : valorMedido(c);
+    return {
+        arco: medido(consumoDoEscopoNaUnidade(medicao, 'arco', o.arco.unidade)),
+        ...(daConta ? { conta: medido(consumoDoEscopoNaUnidade(medicao, { conta }, daConta.unidade)) } : {}),
+        ...(doRuntime ? { runtime: medido(consumoDoEscopoNaUnidade(medicao, { runtime }, doRuntime.unidade)) } : {}),
+    };
+}
+/** Uma medida em texto para pessoa: o valor com a unidade e o rótulo, ou a lacuna. */
+function textoDoConsumo(c) {
+    if (c.valor === null)
+        return `lacuna (${c.lacunas.join('; ') || 'consumo desconhecido'})`;
+    const valor = c.unidade === 'percentual-da-cota' ? `${Math.round(c.valor * 10) / 10}%` : `${c.valor} ${c.unidade}`;
+    return `${c.tetoSuperior ? 'até ' : ''}${valor}${c.parcial ? ' até agora (sessão em voo)' : ''}${c.tetoSuperior ? ' (teto superior)' : ''}`;
+}