@orkastery/cli 0.2.0

package/dist/thread.js

@@ -0,0 +1,333 @@
+"use strict";
+/**
+ * `ork thread new|list|status`: o estado da thread em disco.
+ *
+ * O `thread.json` e a fonte unica da verdade da thread: fases, modo de conducao, base
+ * carimbada pelo `ork` (nunca escolhida pelo executor), worktree e sessoes despachadas.
+ */
+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.dirThreads = dirThreads;
+exports.dirThread = dirThread;
+exports.caminhoThread = caminhoThread;
+exports.listarIds = listarIds;
+exports.lerThread = lerThread;
+exports.gravarThread = gravarThread;
+exports.idDisponivel = idDisponivel;
+exports.criarWorktree = criarWorktree;
+exports.novaThread = novaThread;
+exports.blocoDaThread = blocoDaThread;
+exports.pausaNaThread = pausaNaThread;
+exports.pausasDaThread = pausasDaThread;
+exports.resumoDaThread = resumoDaThread;
+exports.tabelaDeThreads = tabelaDeThreads;
+exports.exigirFase = exigirFase;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const ciclos_1 = require("./ciclos");
+const modos_1 = require("./modos");
+const manifest_1 = require("./manifest");
+const slug_1 = require("./slug");
+const util_1 = require("./util");
+const ledger_1 = require("./ledger");
+/** Diretorio de threads do projeto. */
+function dirThreads(raiz) {
+    return path.join((0, manifest_1.dirEstado)(raiz), 'threads');
+}
+/** Diretorio de uma thread. */
+function dirThread(raiz, id) {
+    return path.join(dirThreads(raiz), id);
+}
+/** Caminho do `thread.json`. */
+function caminhoThread(raiz, id) {
+    return path.join(dirThread(raiz, id), 'thread.json');
+}
+/** Ids das threads existentes, em ordem alfabetica. */
+function listarIds(raiz) {
+    const dir = dirThreads(raiz);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && fs.existsSync(caminhoThread(raiz, e.name)))
+        .map((e) => e.name)
+        .sort();
+}
+/** Le uma thread do disco. */
+function lerThread(raiz, id) {
+    const caminho = caminhoThread(raiz, id);
+    if (!fs.existsSync(caminho)) {
+        throw new Error(`thread "${id}" nao encontrada em ${dirThreads(raiz)}`);
+    }
+    return (0, util_1.lerJson)(caminho);
+}
+/** Grava a thread, sempre atualizando o carimbo de alteracao. */
+function gravarThread(raiz, thread) {
+    thread.atualizadaEm = (0, util_1.agora)();
+    (0, util_1.gravarJson)(caminhoThread(raiz, thread.id), thread);
+}
+/** Carimba a base da thread: branch e commit reais no momento da criacao. */
+function carimbarBase(raiz) {
+    const branch = (0, util_1.exec)('git', ['rev-parse', '--abbrev-ref', 'HEAD'], raiz);
+    const commit = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], raiz);
+    return {
+        branch: branch.ok ? branch.stdout.trim() : 'desconhecida',
+        commit: commit.ok ? commit.stdout.trim() : 'desconhecido',
+    };
+}
+/** Resolve um id livre a partir do assunto normalizado (`<abbrev>-<assunto>`). */
+function idDisponivel(raiz, abbrev, assunto) {
+    let candidato = assunto;
+    let n = 1;
+    while (fs.existsSync(dirThread(raiz, `${abbrev}-${candidato}`))) {
+        n += 1;
+        const sufixo = String(n);
+        candidato = assunto.slice(0, 12 - sufixo.length) + sufixo;
+    }
+    return { id: `${abbrev}-${candidato}`, assunto: candidato };
+}
+/**
+ * Cria a worktree isolada da thread (paralelismo sem colisao entre threads).
+ *
+ * A base vem de `worktree.base_branch` do manifesto e e resolvida em commit antes do
+ * `git worktree add`; depois de criar, o `ork` confere em `git worktree list --porcelain`
+ * que a worktree existe de fato, em vez de confiar no codigo de saida do git.
+ */
+function criarWorktree(carregado, id, slug, opcoes = {}) {
+    const { raiz, manifesto } = carregado;
+    const dir = path.resolve(raiz, manifesto.worktree.dir, id);
+    const branch = opcoes.branchExistente ?? `ork/${slug}`;
+    if (fs.existsSync(dir)) {
+        throw new Error(`worktree ja existe em ${dir}`);
+    }
+    const base = opcoes.base ?? manifesto.worktree.base_branch;
+    const commitBase = (0, util_1.exec)('git', ['rev-parse', '--verify', base], raiz);
+    const ref = commitBase.ok ? commitBase.stdout.trim() : 'HEAD';
+    // Branch nova (`-b`) no caso comum; branch que ja existe no ciclo `merge-branch`.
+    const argumentos = opcoes.branchExistente
+        ? ['worktree', 'add', dir, opcoes.branchExistente]
+        : ['worktree', 'add', '-b', branch, dir, ref];
+    const r = (0, util_1.exec)('git', argumentos, raiz);
+    if (!r.ok) {
+        throw new Error(`git worktree add falhou: ${(r.stderr || r.stdout).trim()}`);
+    }
+    const lista = (0, util_1.exec)('git', ['worktree', 'list', '--porcelain'], raiz);
+    const criada = lista.ok && lista.stdout.split('\n').some((l) => l.trim() === `worktree ${dir}`);
+    if (!criada) {
+        throw new Error(`worktree nao apareceu em \`git worktree list\` apos a criacao: ${dir}`);
+    }
+    return { dir, branch };
+}
+/** Cria a thread: valida modo contra o manifesto, gera o slug e carimba a base. */
+function novaThread(carregado, opcoes) {
+    const { raiz, manifesto } = carregado;
+    const permitidos = manifesto.conduction.allowed_modes;
+    if (!permitidos.includes(opcoes.modo)) {
+        throw new Error(`modo ${modos_1.MODOS[opcoes.modo].tag} fora de conduction.allowed_modes ` +
+            `(permitidos: ${permitidos.map((m) => modos_1.MODOS[m].tag).join(', ')})`);
+    }
+    const assuntoBruto = (0, slug_1.normalizarAssunto)(opcoes.assunto ?? opcoes.nome);
+    if (!assuntoBruto) {
+        throw new Error(`nome "${opcoes.nome}" nao produz assunto valido (esperado [a-z0-9])`);
+    }
+    const abbrev = manifesto.project.abbrev;
+    const def = (0, modos_1.definicaoDoModo)(opcoes.modo);
+    const variante = opcoes.variante ?? null;
+    // A variante muda o desenho dos blocos ANTES do slug: a parte 3 do slug vem do
+    // primeiro bloco, entao um ciclo `goal-plan` ja nasce com o slug `f12`.
+    const blocos = (0, ciclos_1.aplicarVariante)(def.blocos, variante);
+    if (variante) {
+        const dv = (0, ciclos_1.definicaoDaVariante)(variante);
+        if (dv.exigeBranch && !opcoes.branch) {
+            throw new Error(`o ciclo ${variante} parte de uma branch que ja existe: informe --branch <branch>`);
+        }
+        if (opcoes.branch) {
+            const existe = (0, util_1.exec)('git', ['rev-parse', '--verify', `refs/heads/${opcoes.branch}`], raiz);
+            if (!existe.ok) {
+                throw new Error(`branch "${opcoes.branch}" nao existe neste repositorio`);
+            }
+        }
+    }
+    else if (opcoes.branch) {
+        throw new Error('--branch so vale com --ciclo merge-branch');
+    }
+    const { id, assunto } = opcoes.dryRun
+        ? { id: `${abbrev}-${assuntoBruto}`, assunto: assuntoBruto }
+        : idDisponivel(raiz, abbrev, assuntoBruto);
+    const slug = opcoes.slug ?? (0, slug_1.montarSlug)(abbrev, assunto, blocos[0].slugFases);
+    // O override `--slug` do builder tambem passa pela regex canonica.
+    if (!(0, slug_1.slugValido)(slug)) {
+        throw new Error(`slug invalido: "${slug}" (regex canonica: ${slug_1.REGEX_SLUG.source})`);
+    }
+    const thread = {
+        id,
+        slug,
+        nome: opcoes.nome,
+        assunto,
+        modo: opcoes.modo,
+        fases: blocos.flatMap((b) => b.fases),
+        blocos,
+        faseAtual: blocos[0].fases[0],
+        status: 'aberta',
+        criadaEm: (0, util_1.agora)(),
+        atualizadaEm: (0, util_1.agora)(),
+        projeto: { name: manifesto.project.name, abbrev },
+        base: carimbarBase(raiz),
+        worktree: opcoes.worktree ?? null,
+        sessoes: [],
+        decisoes: [],
+        claims: [],
+        leases: [],
+        baseline: null,
+        variante,
+        score: null,
+    };
+    if (variante === 'feature-xl-faseada')
+        thread.fatias = opcoes.fatias ?? 3;
+    if (opcoes.dryRun)
+        return { thread, gravada: false };
+    let worktreeCriada = null;
+    // `greenfield`, `merge-branch` e `feature-xl-faseada` exigem worktree isolada: sao os
+    // ciclos que escrevem codigo em paralelo com outras threads.
+    const exigeWorktree = variante ? (0, ciclos_1.definicaoDaVariante)(variante).exigeWorktree : false;
+    if (opcoes.criarWorktree || exigeWorktree) {
+        worktreeCriada = criarWorktree(carregado, id, slug, {
+            branchExistente: opcoes.branch,
+        });
+        thread.worktree = worktreeCriada.dir;
+        const commitDaBranch = (0, util_1.exec)('git', ['rev-parse', worktreeCriada.branch], raiz);
+        thread.base = {
+            branch: worktreeCriada.branch,
+            commit: commitDaBranch.ok ? commitDaBranch.stdout.trim() : thread.base.commit,
+        };
+    }
+    gravarThread(raiz, thread);
+    (0, ledger_1.registrar)(dirThread(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.threadCriada, {
+        slug,
+        modo: opcoes.modo,
+        tag: def.tag,
+        blocos: def.blocos.map((b) => ({ fases: b.fases, pausa: b.pausa, slug: b.slugFases })),
+        pausas: blocos.filter((b) => b.pausa).length,
+        base: thread.base,
+        projeto: manifesto.project.name,
+        worktree: thread.worktree,
+        variante,
+        branchDeOrigem: opcoes.branch ?? null,
+    });
+    if (worktreeCriada) {
+        (0, ledger_1.registrar)(dirThread(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeCriada, {
+            dir: worktreeCriada.dir,
+            branch: worktreeCriada.branch,
+            base: manifesto.worktree.base_branch,
+            fonte: 'git worktree list --porcelain',
+        });
+    }
+    return { thread, gravada: true };
+}
+/**
+ * O bloco de loop que conduz a fase DESTA thread.
+ *
+ * Le `thread.blocos`, nao a matriz do modo: uma variante de ciclo (`--ciclo goal-plan`,
+ * `--ciclo gap`) redesenha os blocos da thread, e o prompt e o slug precisam seguir o
+ * desenho que a thread realmente tem.
+ */
+function blocoDaThread(thread, fase) {
+    const achado = thread.blocos.find((b) => b.fases.includes(fase));
+    if (!achado) {
+        throw new Error(`fase ${fase} nao pertence a nenhum bloco da thread ${thread.id}`);
+    }
+    return achado;
+}
+/** A fase pausa para o humano ao fechar seu bloco NESTA thread? */
+function pausaNaThread(thread, fase) {
+    const b = blocoDaThread(thread, fase);
+    return b.pausa && b.fases[b.fases.length - 1] === fase;
+}
+/** Pausas humanas do ciclo real da thread (modo + variante). */
+function pausasDaThread(thread) {
+    return thread.blocos.filter((b) => b.pausa).length;
+}
+/** Texto do resumo de uma thread recem-criada ou consultada. */
+function resumoDaThread(thread) {
+    const def = (0, modos_1.definicaoDoModo)(thread.modo);
+    const linhas = [];
+    linhas.push(`  id        ${thread.id}`);
+    linhas.push(`  slug      ${thread.slug}`);
+    linhas.push(`  nome      ${thread.nome}`);
+    linhas.push(`  modo      ${def.tag} (${pausasDaThread(thread)} pausas humanas)`);
+    linhas.push(`  ciclo     ${thread.variante ?? 'padrao do modo'}`);
+    linhas.push(`  fase      ${thread.faseAtual}`);
+    linhas.push(`  status    ${thread.status}`);
+    linhas.push(`  base      ${thread.base.branch} @ ${thread.base.commit.slice(0, 8)}`);
+    linhas.push(`  worktree  ${thread.worktree ?? '(raiz do projeto)'}`);
+    if (thread.score) {
+        linhas.push(`  score     ${thread.score.valor}/5 por ${thread.score.avaliadoPor} ` +
+            `(${thread.score.regime}) em ${thread.score.avaliadoEm}`);
+    }
+    linhas.push('  blocos');
+    for (const b of thread.blocos) {
+        const marca = b.pausa ? `pausa: ${b.pausaSobre}` : 'sem pausa (decisao autonoma no ledger)';
+        linhas.push(`    ${b.slugFases.padEnd(6)} ${b.fases.join('-').padEnd(18)} ${marca}`);
+    }
+    return linhas.join('\n');
+}
+/** Tabela de `ork thread list`. */
+function tabelaDeThreads(raiz) {
+    const ids = listarIds(raiz);
+    if (ids.length === 0) {
+        return 'Nenhuma thread em .orkastery/threads. Crie uma com: ork thread new "<nome>" --modo default';
+    }
+    const linhas = ids.map((id) => {
+        const t = lerThread(raiz, id);
+        return [
+            t.id,
+            t.slug,
+            (0, modos_1.tagDoModo)(t.modo),
+            t.faseAtual,
+            t.status,
+            String(pausasDaThread(t)),
+            String(t.sessoes.length),
+        ];
+    });
+    return (0, util_1.tabela)(['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'PAUSAS', 'SESSOES'], linhas);
+}
+/** Fase valida e pertencente ao ciclo da thread. */
+function exigirFase(thread, bruto) {
+    const fase = bruto.toUpperCase();
+    if (!thread.fases.includes(fase)) {
+        throw new Error(`fase invalida: "${bruto}" (esperado uma de ${thread.fases.join(', ')})`);
+    }
+    return fase;
+}

package/dist/tokens.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * `ork gate next`: o gate de tokens (visao unificada, secao 3.6).
+ *
+ * Ao fim de cada fase, ANTES de despachar o proximo passo, o `ork` mede a lotacao da
+ * janela da sessao atual e decide entre continuar na MESMA sessao ou abrir uma NOVA.
+ *
+ * Honestidade de medicao, a regra que manda aqui:
+ *   - `runtime_reported`: o runtime adapter sabe ler o uso de contexto. O `claude-bg`
+ *     HOJE nao sabe (medido na versao 2.1.259), entao esta fonte nao aparece ainda.
+ *   - `estimated`: existe transcript em disco; a estimativa e por tamanho, com o metodo
+ *     e a janela nominal declarados na propria medida.
+ *   - `informada`: o host adaptador (ou o operador) passou a ocupacao explicitamente.
+ *   - `unavailable`: nada sabe medir. Nesse caso NAO se rotaciona, porque decidir
+ *     rotacao por dado que nao existe e pior do que nao decidir. O veredito sai como
+ *     `same-session` com `decididoPor: ausencia-de-medida`, e o ledger diz isso.
+ *
+ * Numero inventado nao entra aqui em nenhuma hipotese.
+ */
+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.BYTES_POR_TOKEN = exports.JANELA_NOMINAL_PADRAO = void 0;
+exports.passoEhPesado = passoEhPesado;
+exports.medirOcupacao = medirOcupacao;
+exports.gateDeTokens = gateDeTokens;
+exports.textoDoGateDeTokens = textoDoGateDeTokens;
+const fs = __importStar(require("node:fs"));
+const adapter = __importStar(require("./adapters/claude-bg"));
+const ledger_1 = require("./ledger");
+const modos_1 = require("./modos");
+const phase_1 = require("./phase");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+/**
+ * Janela nominal usada na estimativa por transcript.
+ * Declarada, nao escondida: quem le a medida sabe contra o que ela foi calculada.
+ */
+exports.JANELA_NOMINAL_PADRAO = 200000;
+/** Aproximacao classica de tokenizacao para texto tecnico: ~4 bytes por token. */
+exports.BYTES_POR_TOKEN = 4;
+/** Passos pesados: GO e CHECK, e refazer uma fase reprovada (visao, secao 3.6). */
+function passoEhPesado(proximo, refazer) {
+    return refazer || proximo === 'GO' || proximo === 'CHECK';
+}
+/** Mede a ocupacao da janela, na ordem de confiabilidade das fontes. */
+function medirOcupacao(thread, opcoes) {
+    if (typeof opcoes.ocupacao === 'number' && Number.isFinite(opcoes.ocupacao)) {
+        const valor = Math.max(0, Math.min(1, opcoes.ocupacao));
+        const fonte = opcoes.fonte === 'runtime_reported' || opcoes.fonte === 'estimated'
+            ? opcoes.fonte
+            : 'informada';
+        return {
+            ocupacao: valor,
+            fonte,
+            detalhe: `ocupacao ${(valor * 100).toFixed(1)}% declarada pelo chamador como fonte ${fonte}`,
+        };
+    }
+    if (opcoes.transcript) {
+        if (!fs.existsSync(opcoes.transcript)) {
+            return {
+                ocupacao: null,
+                fonte: 'unavailable',
+                detalhe: `transcript informado nao existe: ${opcoes.transcript}`,
+            };
+        }
+        const bytes = fs.statSync(opcoes.transcript).size;
+        const janela = opcoes.janela ?? exports.JANELA_NOMINAL_PADRAO;
+        const tokens = bytes / exports.BYTES_POR_TOKEN;
+        const valor = Math.max(0, Math.min(1, tokens / janela));
+        return {
+            ocupacao: valor,
+            fonte: 'estimated',
+            detalhe: `estimativa por tamanho: ${bytes} bytes / ${exports.BYTES_POR_TOKEN} bytes por token = ` +
+                `~${Math.round(tokens)} tokens de uma janela nominal de ${janela}`,
+        };
+    }
+    // O runtime adapter e a fonte preferida; hoje ele declara que nao sabe medir.
+    const ultima = thread.sessoes[thread.sessoes.length - 1];
+    const chave = opcoes.sessao ?? ultima?.sessionId ?? '';
+    const doRuntime = chave ? adapter.ocupacaoDeContexto(chave) : null;
+    if (doRuntime !== null) {
+        return {
+            ocupacao: Math.max(0, Math.min(1, doRuntime)),
+            fonte: 'runtime_reported',
+            detalhe: `uso de contexto lido do runtime para a sessao ${chave}`,
+        };
+    }
+    return {
+        ocupacao: null,
+        fonte: 'unavailable',
+        detalhe: 'o adapter claude-bg nao expoe uso de contexto nesta versao do runtime; ' +
+            'nenhuma outra fonte foi informada (--ocupacao ou --transcript)',
+    };
+}
+/**
+ * Roda o gate de tokens: mede, decide e DOCUMENTA no ledger.
+ * Nao despacha nada: quem despacha e o `ork phase run`, com o slug que este gate sugere.
+ */
+function gateDeTokens(carregado, threadId, opcoes = {}) {
+    const { raiz, manifesto } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    const proximo = opcoes.proximo ?? thread.faseAtual;
+    const refazer = opcoes.refazer === true;
+    const pesado = passoEhPesado(proximo, refazer);
+    const medida = medirOcupacao(thread, opcoes);
+    const limiares = {
+        rotate_above: manifesto.handoff.rotate_above,
+        force_rotate_above: manifesto.handoff.force_rotate_above,
+    };
+    let veredito = 'same-session';
+    let decididoPor = 'medicao';
+    let razao = '';
+    if (medida.ocupacao === null) {
+        veredito = 'same-session';
+        decididoPor = 'ausencia-de-medida';
+        razao =
+            'ocupacao da janela nao e medivel (fonte unavailable): a rotacao NAO e decidida por ' +
+                'dado inexistente. Siga na mesma sessao e rotacione por decisao explicita se precisar.';
+    }
+    else if (medida.ocupacao >= limiares.force_rotate_above) {
+        veredito = 'new-session';
+        razao =
+            `ocupacao ${(medida.ocupacao * 100).toFixed(1)}% >= force_rotate_above ` +
+                `(${(limiares.force_rotate_above * 100).toFixed(0)}%): rotaciona sempre, ` +
+                'independente do peso do proximo passo.';
+    }
+    else if (medida.ocupacao >= limiares.rotate_above && pesado) {
+        veredito = 'new-session';
+        razao =
+            `ocupacao ${(medida.ocupacao * 100).toFixed(1)}% >= rotate_above ` +
+                `(${(limiares.rotate_above * 100).toFixed(0)}%) e o proximo passo e pesado ` +
+                `(${refazer ? 'refazer fase reprovada' : proximo}): mais janela significa mais acuracia.`;
+    }
+    else if (medida.ocupacao >= limiares.rotate_above) {
+        razao =
+            `ocupacao ${(medida.ocupacao * 100).toFixed(1)}% >= rotate_above, mas o proximo passo ` +
+                `(${proximo}) nao e pesado: segue na mesma sessao.`;
+    }
+    else {
+        razao =
+            `ocupacao ${(medida.ocupacao * 100).toFixed(1)}% abaixo de rotate_above ` +
+                `(${(limiares.rotate_above * 100).toFixed(0)}%): segue na mesma sessao.`;
+    }
+    // O slug da proxima sessao: outra parte de fases quando o bloco muda, sufixo de
+    // rotacao quando a sessao nova conduz um bloco que a thread ja abriu.
+    const slugSugerido = veredito === 'new-session' ? (0, phase_1.slugDaSessao)(thread, proximo) : null;
+    const resultado = {
+        thread: threadId,
+        medida,
+        proximoPasso: proximo,
+        passoPesado: pesado,
+        veredito,
+        decididoPor,
+        razao,
+        slugSugerido,
+        limiares,
+        decididoEm: (0, util_1.agora)(),
+    };
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.gateDeTokens, {
+        ocupacao: medida.ocupacao,
+        fonte: medida.fonte,
+        fonteDetalhe: medida.detalhe,
+        proximoPasso: proximo,
+        bloco: (0, modos_1.blocoDaFase)(thread.modo, proximo).fases.join('-'),
+        passoPesado: pesado,
+        veredito,
+        decididoPor,
+        razao,
+        slugSugerido,
+        limiares,
+    });
+    const atualizada = (0, thread_1.lerThread)(raiz, threadId);
+    atualizada.ultimoTokenGate = resultado;
+    (0, thread_1.gravarThread)(raiz, atualizada);
+    return resultado;
+}
+/** Texto de `ork gate next`. */
+function textoDoGateDeTokens(v) {
+    const linhas = [];
+    linhas.push(`ork gate next: thread ${v.thread}`);
+    linhas.push(`  ocupacao       ${v.medida.ocupacao === null ? 'nao medivel' : `${(v.medida.ocupacao * 100).toFixed(1)}%`}`);
+    linhas.push(`  fonte          ${v.medida.fonte}`);
+    linhas.push(`                 ${v.medida.detalhe}`);
+    linhas.push(`  limiares       rotate_above ${v.limiares.rotate_above} | force_rotate_above ${v.limiares.force_rotate_above}`);
+    linhas.push(`  proximo passo  ${v.proximoPasso} (${v.passoPesado ? 'pesado' : 'leve'})`);
+    linhas.push('');
+    linhas.push(`VEREDITO: ${v.veredito}  (decidido por ${v.decididoPor})`);
+    linhas.push(`  razao: ${v.razao}`);
+    if (v.slugSugerido) {
+        linhas.push(`  slug da nova sessao: ${v.slugSugerido}`);
+        linhas.push(`  proximo passo: ork handoff export ${v.thread} --proxima-fase ${v.proximoPasso}`);
+    }
+    linhas.push('');
+    linhas.push(`Registrado no ledger como token_gate: ork phase list ${v.thread}`);
+    return linhas.join('\n');
+}

package/dist/types.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Tipos centrais do nucleo `ork`.
+ *
+ * Regra de ouro herdada do Devmaster: o agente decide, o `ork` verifica.
+ * Nada aqui depende de LLM; tudo e deterministico e testavel.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIGITO_DA_FASE = exports.FASES = void 0;
+/** Ordem canonica das fases. */
+exports.FASES = ['GOAL', 'PLAN', 'GO', 'CHECK', 'SHIP', 'MASTER'];
+/** Alias numerico herdado do Devmaster (F1..F6), usado na parte 3 do slug. */
+exports.DIGITO_DA_FASE = {
+    GOAL: '1',
+    PLAN: '2',
+    GO: '3',
+    CHECK: '4',
+    SHIP: '5',
+    MASTER: '6',
+};