@orkastery/cli 0.2.0

package/dist/leases.js

@@ -0,0 +1,508 @@
+"use strict";
+/**
+ * Leases de exclusao mutua entre threads (`.orkastery/leases/<nome>.json`).
+ *
+ * O lease `main-tree` serializa o SHIP: com N threads paralelas, so uma mergeia por vez.
+ * A aquisicao e atomica de verdade (`open` com flag `wx`, que falha se o arquivo existe),
+ * nao um "checa e depois escreve" que perde a corrida.
+ *
+ * O lease tem TTL: sessao morta nao pode travar a fila para sempre. Um lease vencido e
+ * tomado, e a tomada vai ao ledger da thread que tomou, com quem estava segurando.
+ *
+ * Bloco B2: alem do `main-tree`, existem as familias `worktree-write:<thread>`,
+ * `path:<glob>`, `board:<card>` e `service:<porta>`, e uma FILA por colisao. Duas threads
+ * que pedem a mesma regiao de path nao brigam: a segunda entra na fila em FIFO e recebe
+ * o motivo tipado `lease.busy` com a correcao acionavel.
+ */
+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.NOME_ARQUIVO_FILA = exports.FAMILIAS_DE_LEASE = exports.TTL_PADRAO_MS = exports.LEASE_MAIN_TREE = void 0;
+exports.dirLeases = dirLeases;
+exports.nomeDeLease = nomeDeLease;
+exports.tipoDoLease = tipoDoLease;
+exports.alvoDoLease = alvoDoLease;
+exports.caminhoLease = caminhoLease;
+exports.lerLease = lerLease;
+exports.expirado = expirado;
+exports.globParaRegex = globParaRegex;
+exports.caminhoBateComGlob = caminhoBateComGlob;
+exports.globsColidem = globsColidem;
+exports.leasesColidem = leasesColidem;
+exports.adquirir = adquirir;
+exports.liberar = liberar;
+exports.listarLeases = listarLeases;
+exports.leasesColidentes = leasesColidentes;
+exports.leasesDaThread = leasesDaThread;
+exports.caminhoFila = caminhoFila;
+exports.lerFila = lerFila;
+exports.enfileirar = enfileirar;
+exports.sairDaFila = sairDaFila;
+exports.esperandoPor = esperandoPor;
+exports.posicaoNaFila = posicaoNaFila;
+exports.proximoDaFila = proximoDaFila;
+exports.adquirirRegiao = adquirirRegiao;
+exports.tabelaDeLeases = tabelaDeLeases;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const manifest_1 = require("./manifest");
+const util_1 = require("./util");
+/** Nome do lease que serializa o merge na base (visao, paridade 5). */
+exports.LEASE_MAIN_TREE = 'main-tree';
+/** TTL padrao de 30 minutos: um SHIP que passe disso deixou de existir. */
+exports.TTL_PADRAO_MS = 30 * 60 * 1000;
+/** As familias de lease do B2, com o que cada uma protege. */
+exports.FAMILIAS_DE_LEASE = {
+    'main-tree': 'a arvore que tem a branch base em check-out (serializa o merge)',
+    'worktree-write': 'a escrita na worktree de uma thread',
+    path: 'uma regiao de arquivos por glob (colisao entre threads paralelas)',
+    board: 'um card do board, para duas threads nao pegarem o mesmo cartao',
+    service: 'uma porta de servico local, para dois runs nao subirem no mesmo lugar',
+};
+/** Diretorio dos leases do projeto. */
+function dirLeases(raiz) {
+    return path.join((0, manifest_1.dirEstado)(raiz), 'leases');
+}
+/**
+ * Nome canonico de um lease de familia tipada: `path:core/src/**`, `service:5173`.
+ * `main-tree` nao tem alvo: e um so no projeto.
+ */
+function nomeDeLease(tipo, alvo) {
+    if (tipo === 'main-tree')
+        return exports.LEASE_MAIN_TREE;
+    const limpo = (alvo ?? '').trim();
+    if (!limpo)
+        throw new Error(`lease ${tipo} exige um alvo (ex.: ${tipo}:<alvo>)`);
+    return `${tipo}:${limpo}`;
+}
+/** Familia de um nome de lease. Nome fora do catalogo cai em `path` por seguranca. */
+function tipoDoLease(nome) {
+    if (nome === exports.LEASE_MAIN_TREE)
+        return 'main-tree';
+    const prefixo = nome.split(':')[0];
+    if (prefixo === 'worktree-write' || prefixo === 'path' || prefixo === 'board' || prefixo === 'service') {
+        return prefixo;
+    }
+    return 'path';
+}
+/** Alvo de um lease tipado (o que vem depois dos dois pontos). */
+function alvoDoLease(nome) {
+    const corte = nome.indexOf(':');
+    return corte < 0 ? '' : nome.slice(corte + 1);
+}
+/**
+ * Caminho do arquivo de um lease. O nome canonico tem `:`, `/` e `*`, entao ele e
+ * codificado para virar um nome de arquivo unico e reversivel. `main-tree` fica
+ * inalterado, o que preserva os leases gravados pelo bloco B1.
+ */
+function caminhoLease(raiz, nome) {
+    return path.join(dirLeases(raiz), `${encodeURIComponent(nome)}.json`);
+}
+/** Le o lease em disco. Arquivo corrompido conta como lease ausente. */
+function lerLease(raiz, nome) {
+    const caminho = caminhoLease(raiz, nome);
+    if (!fs.existsSync(caminho))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(caminho, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** O lease venceu? */
+function expirado(lease, referencia = new Date()) {
+    const fim = Date.parse(lease.expiraEm);
+    return Number.isFinite(fim) ? fim <= referencia.getTime() : true;
+}
+// ---------------------------------------------------------------------------
+// Colisao de regiao: glob para regex, e a pergunta "estes dois globs se cruzam?".
+// ---------------------------------------------------------------------------
+/** Converte um glob de path (`*`, `**`, `?`) na regex equivalente. */
+function globParaRegex(glob) {
+    let re = '';
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === '*') {
+            if (glob[i + 1] === '*') {
+                // `**` atravessa quantos segmentos vierem; `**/` consome a propria barra.
+                re += '.*';
+                i++;
+                if (glob[i + 1] === '/')
+                    i++;
+            }
+            else {
+                re += '[^/]*';
+            }
+        }
+        else if (c === '?') {
+            re += '[^/]';
+        }
+        else {
+            re += c.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        }
+    }
+    return new RegExp(`^${re}$`);
+}
+/** O caminho concreto cai dentro do glob? */
+function caminhoBateComGlob(caminho, glob) {
+    return globParaRegex(glob).test(caminho);
+}
+/** Parte literal do glob, antes do primeiro curinga. */
+function prefixoLiteral(glob) {
+    const corte = glob.search(/[*?]/);
+    return corte < 0 ? glob : glob.slice(0, corte);
+}
+/** `a` e prefixo de `b` numa fronteira de caminho (evita casar `core/s` com `core/src`). */
+function prefixoDeCaminho(a, b) {
+    if (a === '')
+        return false;
+    if (!b.startsWith(a))
+        return false;
+    return a.length === b.length || a.endsWith('/') || b[a.length] === '/';
+}
+/**
+ * Dois globs disputam a mesma regiao?
+ *
+ * Conservador de proposito: na duvida o `ork` prefere serializar duas threads a deixar
+ * as duas escreverem no mesmo lugar. Falso positivo custa espera; falso negativo custa
+ * conflito de merge no meio do GO.
+ */
+function globsColidem(a, b) {
+    if (a === b)
+        return true;
+    if (globParaRegex(a).test(b) || globParaRegex(b).test(a))
+        return true;
+    const pa = prefixoLiteral(a);
+    const pb = prefixoLiteral(b);
+    return prefixoDeCaminho(pa, pb) || prefixoDeCaminho(pb, pa);
+}
+/**
+ * Dois nomes de lease colidem?
+ *
+ * Familias diferentes nunca colidem. Dentro da familia `path` vale a colisao de glob;
+ * nas demais familias o alvo e discreto (uma thread, um card, uma porta) e a colisao
+ * e a igualdade exata.
+ */
+function leasesColidem(a, b) {
+    if (a === b)
+        return true;
+    const ta = tipoDoLease(a);
+    const tb = tipoDoLease(b);
+    if (ta !== tb)
+        return false;
+    if (ta === 'path')
+        return globsColidem(alvoDoLease(a), alvoDoLease(b));
+    return false;
+}
+/**
+ * Adquire o lease. Retorna `ok: false` com `ocupadoPor` quando outra thread o segura,
+ * em vez de esperar: quem decide esperar ou desistir e a fila (`adquirirRegiao`).
+ */
+function adquirir(raiz, nome, opcoes) {
+    const caminho = caminhoLease(raiz, nome);
+    fs.mkdirSync(path.dirname(caminho), { recursive: true });
+    const ttl = opcoes.ttlMs ?? exports.TTL_PADRAO_MS;
+    const lease = {
+        nome,
+        thread: opcoes.thread,
+        motivo: opcoes.motivo,
+        pid: process.pid,
+        adquiridoEm: (0, util_1.agora)(),
+        expiraEm: new Date(Date.now() + ttl).toISOString(),
+    };
+    const corpo = JSON.stringify(lease, null, 2) + '\n';
+    for (const tentativa of [1, 2]) {
+        try {
+            // `wx` falha se o arquivo existe: e a atomicidade do lease, sem corrida.
+            fs.writeFileSync(caminho, corpo, { encoding: 'utf8', flag: 'wx' });
+            return { ok: true, lease, ocupadoPor: null, tomadoDeVencido: tentativa === 2 };
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+            const atual = lerLease(raiz, nome);
+            if (atual && !expirado(atual)) {
+                return { ok: false, lease: null, ocupadoPor: atual, tomadoDeVencido: false };
+            }
+            // Lease vencido ou corrompido: remove e tenta uma unica vez mais.
+            try {
+                fs.unlinkSync(caminho);
+            }
+            catch {
+                /* outra thread removeu antes; a segunda tentativa decide */
+            }
+        }
+    }
+    const atual = lerLease(raiz, nome);
+    return { ok: false, lease: null, ocupadoPor: atual, tomadoDeVencido: false };
+}
+/**
+ * Libera o lease. Sem `forcar`, so a thread que o segura pode liberar: liberar o lease
+ * dos outros e exatamente o bug que o lease existe para impedir.
+ */
+function liberar(raiz, nome, thread, forcar = false) {
+    const atual = lerLease(raiz, nome);
+    if (!atual) {
+        sairDaFila(raiz, nome, thread);
+        return { ok: true, detalhe: `lease ${nome} ja estava livre` };
+    }
+    if (atual.thread !== thread && !forcar) {
+        return {
+            ok: false,
+            detalhe: `lease ${nome} pertence a thread ${atual.thread}; use --forcar para tomar`,
+        };
+    }
+    fs.unlinkSync(caminhoLease(raiz, nome));
+    sairDaFila(raiz, nome, atual.thread);
+    const proximo = proximoDaFila(raiz, nome);
+    const seguinte = proximo ? `; proximo da fila: thread ${proximo.thread}` : '';
+    return { ok: true, detalhe: `lease ${nome} liberado${seguinte}` };
+}
+/** Todos os leases existentes no projeto, pelo nome canonico gravado no arquivo. */
+function listarLeases(raiz) {
+    const dir = dirLeases(raiz);
+    if (!fs.existsSync(dir))
+        return [];
+    const leases = [];
+    for (const arquivo of fs.readdirSync(dir)) {
+        if (!arquivo.endsWith('.json') || arquivo === exports.NOME_ARQUIVO_FILA)
+            continue;
+        try {
+            const bruto = fs.readFileSync(path.join(dir, arquivo), 'utf8');
+            const lease = JSON.parse(bruto);
+            if (lease && typeof lease.nome === 'string')
+                leases.push(lease);
+        }
+        catch {
+            /* arquivo corrompido conta como lease ausente */
+        }
+    }
+    return leases.sort((a, b) => a.nome.localeCompare(b.nome));
+}
+/** Leases ativos (nao vencidos) que colidem com o nome pedido. */
+function leasesColidentes(raiz, nome, thread) {
+    return listarLeases(raiz).filter((l) => !expirado(l) && l.thread !== thread && leasesColidem(nome, l.nome));
+}
+/** Leases ativos segurados por uma thread. */
+function leasesDaThread(raiz, thread) {
+    return listarLeases(raiz).filter((l) => l.thread === thread && !expirado(l));
+}
+// ---------------------------------------------------------------------------
+// Fila por colisao.
+// ---------------------------------------------------------------------------
+/** Arquivo da fila de espera, ao lado dos leases. */
+exports.NOME_ARQUIVO_FILA = 'fila.json';
+/** Caminho da fila de espera do projeto. */
+function caminhoFila(raiz) {
+    return path.join(dirLeases(raiz), exports.NOME_ARQUIVO_FILA);
+}
+/** Le a fila inteira, em ordem FIFO. Arquivo corrompido conta como fila vazia. */
+function lerFila(raiz) {
+    const caminho = caminhoFila(raiz);
+    if (!fs.existsSync(caminho))
+        return [];
+    try {
+        const dados = JSON.parse(fs.readFileSync(caminho, 'utf8'));
+        return Array.isArray(dados) ? dados.sort((a, b) => a.desdeEm.localeCompare(b.desdeEm)) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function gravarFila(raiz, fila) {
+    const caminho = caminhoFila(raiz);
+    fs.mkdirSync(path.dirname(caminho), { recursive: true });
+    fs.writeFileSync(caminho, JSON.stringify(fila, null, 2) + '\n', 'utf8');
+}
+/** Coloca o pedido na fila (idempotente por thread e nome). Devolve a posicao, 1 = proxima. */
+function enfileirar(raiz, nome, dados) {
+    const fila = lerFila(raiz);
+    const jaEsta = fila.find((p) => p.nome === nome && p.thread === dados.thread);
+    if (!jaEsta) {
+        fila.push({
+            nome,
+            tipo: tipoDoLease(nome),
+            thread: dados.thread,
+            motivo: dados.motivo,
+            desdeEm: (0, util_1.agora)(),
+            colidiuCom: dados.colidiuCom,
+            bloqueadaPor: dados.bloqueadaPor,
+        });
+        gravarFila(raiz, fila);
+    }
+    return posicaoNaFila(raiz, nome, dados.thread);
+}
+/** Tira a thread da fila do lease informado. */
+function sairDaFila(raiz, nome, thread) {
+    const fila = lerFila(raiz);
+    const restante = fila.filter((p) => !(p.nome === nome && p.thread === thread));
+    if (restante.length !== fila.length)
+        gravarFila(raiz, restante);
+}
+/** Espera da regiao: pedidos na fila cujo nome colide com o nome informado, em FIFO. */
+function esperandoPor(raiz, nome) {
+    return lerFila(raiz).filter((p) => leasesColidem(nome, p.nome));
+}
+/** Posicao da thread na fila da regiao (1 = proxima da vez, 0 = fora da fila). */
+function posicaoNaFila(raiz, nome, thread) {
+    const espera = esperandoPor(raiz, nome);
+    const i = espera.findIndex((p) => p.thread === thread && p.nome === nome);
+    return i < 0 ? 0 : i + 1;
+}
+/** Quem esta na frente da fila desta regiao. */
+function proximoDaFila(raiz, nome) {
+    return esperandoPor(raiz, nome)[0] ?? null;
+}
+/**
+ * Adquire uma regiao com fila: se algo colidente estiver ativo, a thread ENTRA NA FILA
+ * e recebe `lease.busy` com correcao acionavel, em vez de escrever por cima.
+ *
+ * A ordem e FIFO pela entrada na fila: quem chegou antes leva, mesmo que a outra thread
+ * tente de novo primeiro. Sem isso a fila vira loteria e a thread azarada nunca entra.
+ */
+function adquirirRegiao(raiz, nome, opcoes) {
+    const tipo = tipoDoLease(nome);
+    const base = { nome, tipo, lease: null, ocupadoPor: null, tomadoDeVencido: false };
+    const colidentes = leasesColidentes(raiz, nome, opcoes.thread);
+    if (colidentes.length > 0) {
+        const dono = colidentes[0];
+        const posicao = enfileirar(raiz, nome, {
+            thread: opcoes.thread,
+            motivo: opcoes.motivo,
+            colidiuCom: dono.nome,
+            bloqueadaPor: dono.thread,
+        });
+        return {
+            ...base,
+            ok: false,
+            ocupadoPor: dono,
+            esperando: true,
+            posicaoNaFila: posicao,
+            colidiuCom: dono,
+            motivo: 'lease.busy',
+            detalhe: `a regiao "${nome}" colide com "${dono.nome}", que esta com a thread ${dono.thread} ` +
+                `desde ${dono.adquiridoEm}`,
+            correcao: `espere a thread ${dono.thread} liberar (posicao ${posicao} na fila), ` +
+                `ou reduza o glob da sua regiao, ou libere com: ork lease release "${dono.nome}" --forcar`,
+        };
+    }
+    // Fila vazia para a regiao? Entao adquire. Se ha fila e a vez nao e desta thread,
+    // ela espera: e isso que impede a thread que chega depois de furar a fila.
+    const espera = esperandoPor(raiz, nome);
+    if (espera.length > 0 && espera[0].thread !== opcoes.thread) {
+        const frente = espera[0];
+        const posicao = enfileirar(raiz, nome, {
+            thread: opcoes.thread,
+            motivo: opcoes.motivo,
+            colidiuCom: frente.nome,
+            bloqueadaPor: frente.thread,
+        });
+        return {
+            ...base,
+            ok: false,
+            ocupadoPor: null,
+            esperando: true,
+            posicaoNaFila: posicao,
+            colidiuCom: null,
+            motivo: 'lease.busy',
+            detalhe: `a thread ${frente.thread} esta na frente da fila da regiao "${frente.nome}"`,
+            correcao: `espere a vez (posicao ${posicao} na fila) ou veja a fila com: ork lease list`,
+        };
+    }
+    const r = adquirir(raiz, nome, opcoes);
+    if (!r.ok) {
+        const dono = r.ocupadoPor;
+        const posicao = enfileirar(raiz, nome, {
+            thread: opcoes.thread,
+            motivo: opcoes.motivo,
+            colidiuCom: nome,
+            bloqueadaPor: dono?.thread ?? '(desconhecida)',
+        });
+        return {
+            ...base,
+            ok: false,
+            ocupadoPor: dono,
+            esperando: true,
+            posicaoNaFila: posicao,
+            colidiuCom: dono,
+            motivo: 'lease.busy',
+            detalhe: `o lease "${nome}" esta com a thread ${dono?.thread ?? '(desconhecida)'}`,
+            correcao: `espere a vez (posicao ${posicao} na fila) ou: ork lease release "${nome}" --forcar`,
+        };
+    }
+    sairDaFila(raiz, nome, opcoes.thread);
+    return {
+        ...base,
+        ok: true,
+        lease: r.lease,
+        tomadoDeVencido: r.tomadoDeVencido,
+        esperando: false,
+        posicaoNaFila: 0,
+        colidiuCom: null,
+        motivo: null,
+        detalhe: `lease ${nome} adquirido pela thread ${opcoes.thread}`,
+        correcao: '',
+    };
+}
+/** Texto de `ork lease list`: leases ativos, familias e a fila por colisao. */
+function tabelaDeLeases(raiz) {
+    const leases = listarLeases(raiz);
+    const fila = lerFila(raiz);
+    const linhas = ['Leases do projeto', ''];
+    if (leases.length === 0) {
+        linhas.push('  Nenhum lease tomado. O merge na base esta liberado.');
+    }
+    else {
+        for (const l of leases) {
+            const situacao = expirado(l) ? 'VENCIDO (tomavel)' : 'ativo';
+            linhas.push(`  ${l.nome.padEnd(28)} [${tipoDoLease(l.nome)}] thread ${l.thread.padEnd(18)} ${situacao}`);
+            linhas.push(`    desde ${l.adquiridoEm} ate ${l.expiraEm} (pid ${l.pid})`);
+            linhas.push(`    motivo: ${l.motivo}`);
+        }
+    }
+    linhas.push('');
+    const merge = fila.filter((p) => p.tipo === 'main-tree');
+    const regiao = fila.filter((p) => p.tipo !== 'main-tree');
+    linhas.push(`Fila de merge (lease ${exports.LEASE_MAIN_TREE}): ${merge.length === 0 ? 'vazia' : `${merge.length} na espera`}`);
+    merge.forEach((p, i) => {
+        linhas.push(`  ${i + 1}. thread ${p.thread} desde ${p.desdeEm} (bloqueada por ${p.bloqueadaPor})`);
+    });
+    linhas.push(`Fila por colisao de regiao: ${regiao.length === 0 ? 'vazia' : `${regiao.length} na espera`}`);
+    regiao.forEach((p, i) => {
+        linhas.push(`  ${i + 1}. thread ${p.thread} quer ${p.nome}, colide com ${p.colidiuCom} ` +
+            `(thread ${p.bloqueadaPor}) desde ${p.desdeEm}`);
+    });
+    return linhas.join('\n');
+}

package/dist/ledger.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Ledger de eventos JSONL por thread (`.orkastery/threads/<id>/ledger.jsonl`).
+ *
+ * O ledger e append-only: e a rastreabilidade da conducao. Toda decisao autonoma
+ * (modo sem pausa) precisa estar aqui com quem decidiu, evidencia e razao.
+ */
+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.TIPOS_DE_EVENTO = void 0;
+exports.caminhoLedger = caminhoLedger;
+exports.registrar = registrar;
+exports.lerLedger = lerLedger;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const util_1 = require("./util");
+/** Tipos de evento do ledger. B0 abriu a lista; o B1 acrescenta os seus. */
+exports.TIPOS_DE_EVENTO = {
+    // Bloco B0
+    threadCriada: 'thread_created',
+    worktreeCriada: 'worktree_created',
+    faseDespachada: 'phase_dispatch',
+    despachoVerificado: 'phase_dispatch_verified',
+    despachoFalhou: 'phase_dispatch_failed',
+    decisaoAutonoma: 'autonomous_decision',
+    pausaHumana: 'human_gate',
+    // Bloco B1: verdade, leases, ship e handoff
+    gateBloqueado: 'gate_blocked',
+    gateLiberado: 'gate_passed',
+    claimRegistrada: 'claim_added',
+    baselineGravada: 'baseline_recorded',
+    verificacao: 'verify_run',
+    leaseAdquirido: 'lease_acquired',
+    leaseLiberado: 'lease_released',
+    shipIniciado: 'ship_started',
+    shipConcluido: 'ship_done',
+    shipBloqueado: 'ship_blocked',
+    gateDeTokens: 'token_gate',
+    handoffExportado: 'handoff_exported',
+    handoffRecuperado: 'handoff_recalled',
+    // Bloco B2: worktree gerenciada, fila de leases, escalonador e MASTER/score
+    worktreeGarantida: 'worktree_ensured',
+    worktreeSincronizada: 'worktree_synced',
+    worktreeAuditada: 'worktree_audited',
+    worktreeLiberada: 'worktree_released',
+    leaseEnfileirado: 'lease_queued',
+    postmortemGravado: 'postmortem_recorded',
+    masterConcluido: 'master_done',
+    // Bloco B5: auditores periodicos (rodada, achados, propostas e board de divida)
+    auditoriaDespachada: 'audit_dispatch',
+    auditoriaBloqueada: 'audit_blocked',
+    auditoriaVerificada: 'audit_verified',
+    achadoRegistrado: 'finding_added',
+    propostaGravada: 'proposal_recorded',
+    relatorioGerado: 'audit_report',
+    achadoVirouThread: 'finding_to_thread',
+    // Extensao do B5: varredura deterministica da superficie de ataque de rede (SP8..SP12)
+    superficieVarrida: 'attack_surface_scanned',
+    // Bloco B6: camada OrkMind (memoria semantica opcional)
+    memoriaGravada: 'memory_written',
+    memoriaInjetada: 'memory_injected',
+    memoriaDegradada: 'memory_degraded',
+    recallResolvido: 'recall_resolved',
+    // Bloco B3: autonomia (retry tipado, fila de rate limit, GO-FIX/CHECK-REVERIFY)
+    retryPlanejado: 'retry_planned',
+    retryTentado: 'retry_attempt',
+    retryEscalado: 'retry_escalated',
+    rateLimitDetectado: 'rate_limit_detected',
+    rateLimitEnfileirado: 'rate_limit_queued',
+    rateLimitRetomado: 'rate_limit_resumed',
+    fixAberto: 'go_fix_opened',
+    fixDespachado: 'go_fix_dispatched',
+    reverifyConcluido: 'check_reverify',
+};
+/** Caminho do ledger de uma thread. */
+function caminhoLedger(dirThread) {
+    return path.join(dirThread, 'ledger.jsonl');
+}
+/** Anexa um evento ao ledger da thread e devolve o evento gravado. */
+function registrar(dirThread, threadId, tipo, dados = {}) {
+    const evento = { ts: (0, util_1.agora)(), thread: threadId, tipo, ...dados };
+    fs.mkdirSync(dirThread, { recursive: true });
+    fs.appendFileSync(caminhoLedger(dirThread), JSON.stringify(evento) + '\n', 'utf8');
+    return evento;
+}
+/** Le o ledger inteiro. Linha corrompida vira evento `ledger_corrupted` em vez de quebrar a leitura. */
+function lerLedger(dirThread) {
+    const caminho = caminhoLedger(dirThread);
+    if (!fs.existsSync(caminho))
+        return [];
+    const linhas = fs.readFileSync(caminho, 'utf8').split('\n').filter((l) => l.trim() !== '');
+    return linhas.map((linha, i) => {
+        try {
+            return JSON.parse(linha);
+        }
+        catch {
+            return {
+                ts: '',
+                thread: '',
+                tipo: 'ledger_corrupted',
+                linha: i + 1,
+                conteudo: linha.slice(0, 200),
+            };
+        }
+    });
+}