@orkastery/cli 0.2.0

package/dist/board.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * `ork board --all` e `ork board plan`: a visao unica e o escalonador por maquina (B2).
+ *
+ * `board --all` responde "o que esta rolando nesta maquina agora", com todas as threads
+ * de todos os perfis encontrados: id, slug, modo, fase, status, pausas, worktree e leases.
+ *
+ * `board plan` responde a pergunta seguinte, que e a que evita incidente: "quem PODE
+ * avancar agora?". Ele respeita duas coisas ao mesmo tempo:
+ *   - `concurrency.max_parallel_threads` do manifesto (quantas threads a maquina aguenta);
+ *   - os leases e a fila por colisao (quem esta na regiao de quem).
+ *
+ * O `main-tree` continua sendo o UNICO gate de merge: o escalonador nao mergeia nada, ele
+ * apenas mostra a fila serializada que o `ork ship` ja obedece.
+ */
+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.perfisDetectados = perfisDetectados;
+exports.threadsDeTodosOsPerfis = threadsDeTodosOsPerfis;
+exports.planejar = planejar;
+exports.textoDoPlano = textoDoPlano;
+exports.textoDoBoard = textoDoBoard;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const leases_1 = require("./leases");
+const manifest_1 = require("./manifest");
+const modos_1 = require("./modos");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+/**
+ * Perfis detectados no projeto.
+ *
+ * O perfil padrao e o do manifesto (`board.default`), servido por `.orkastery/threads`.
+ * Perfis adicionais sao detectados em `.orkastery/perfis/<nome>/`, quando existirem: e
+ * assim que uma segunda configuracao de board entra no `--all` sem mudar o layout de disco.
+ */
+function perfisDetectados(carregado) {
+    const perfis = [
+        { nome: carregado.manifesto.board.default || 'default', raiz: carregado.raiz },
+    ];
+    const dirPerfis = path.join((0, manifest_1.dirEstado)(carregado.raiz), 'perfis');
+    if (fs.existsSync(dirPerfis)) {
+        for (const e of fs.readdirSync(dirPerfis, { withFileTypes: true })) {
+            if (!e.isDirectory())
+                continue;
+            const raiz = path.join(dirPerfis, e.name);
+            if (fs.existsSync(path.join(raiz, '.orkastery', 'threads'))) {
+                perfis.push({ nome: e.name, raiz });
+            }
+        }
+    }
+    return perfis;
+}
+/** Todas as threads de todos os perfis, com os leases e a fila de cada uma. */
+function threadsDeTodosOsPerfis(carregado, todos = true) {
+    const perfis = todos ? perfisDetectados(carregado) : perfisDetectados(carregado).slice(0, 1);
+    const saida = [];
+    for (const perfil of perfis) {
+        const fila = (0, leases_1.lerFila)(perfil.raiz);
+        for (const id of (0, thread_1.listarIds)(perfil.raiz)) {
+            const thread = (0, thread_1.lerThread)(perfil.raiz, id);
+            saida.push({
+                perfil: perfil.nome,
+                raiz: perfil.raiz,
+                thread,
+                leases: (0, leases_1.leasesDaThread)(perfil.raiz, id).map((l) => l.nome),
+                naFila: fila.filter((p) => p.thread === id),
+            });
+        }
+    }
+    return saida;
+}
+/**
+ * Escalonador por maquina: decide quem avanca agora e quem espera, com motivo tipado.
+ *
+ * A ordem e FIFO por criacao da thread. Quem ja segura lease conta como em andamento e
+ * ocupa vaga: e o unico jeito de o limite de paralelismo significar alguma coisa.
+ */
+function planejar(carregado) {
+    const { raiz, manifesto } = carregado;
+    const max = Math.max(1, manifesto.concurrency.max_parallel_threads);
+    const fila = (0, leases_1.lerFila)(raiz);
+    const ativos = (0, leases_1.listarLeases)(raiz).filter((l) => !(0, leases_1.expirado)(l));
+    const threads = (0, thread_1.listarIds)(raiz)
+        .map((id) => (0, thread_1.lerThread)(raiz, id))
+        .sort((a, b) => a.criadaEm.localeCompare(b.criadaEm));
+    const vagas = [];
+    let ocupadas = 0;
+    // 1a passada: quem ja segura lease esta em andamento e ocupa vaga.
+    const emAndamento = new Set();
+    for (const t of threads) {
+        const meus = ativos.filter((l) => l.thread === t.id).map((l) => l.nome);
+        if (t.status === 'fechada' || meus.length === 0)
+            continue;
+        emAndamento.add(t.id);
+        ocupadas += 1;
+        vagas.push({
+            thread: t.id,
+            slug: t.slug,
+            modo: t.modo,
+            fase: t.faseAtual,
+            situacao: 'em-andamento',
+            motivo: null,
+            detalhe: `segura ${meus.join(', ')}`,
+            correcao: '',
+            leases: meus,
+        });
+    }
+    // 2a passada: as demais, em FIFO, ate o limite de paralelismo da maquina.
+    for (const t of threads) {
+        if (emAndamento.has(t.id))
+            continue;
+        if (t.status === 'fechada') {
+            vagas.push({
+                thread: t.id,
+                slug: t.slug,
+                modo: t.modo,
+                fase: t.faseAtual,
+                situacao: 'fechada',
+                motivo: null,
+                detalhe: t.score ? `score ${t.score.valor}/5 registrado` : 'fechada sem score registrado',
+                correcao: t.score ? '' : `ork master ${t.id} --score <0-5> --justificativa "<por que>"`,
+                leases: [],
+            });
+            continue;
+        }
+        if (t.status === 'pausada') {
+            vagas.push({
+                thread: t.id,
+                slug: t.slug,
+                modo: t.modo,
+                fase: t.faseAtual,
+                situacao: 'pausada',
+                motivo: 'human.pending',
+                detalhe: `esperando veredito humano na fase ${t.faseAtual}`,
+                correcao: `ork gate approve ${t.id} <sobre> --por <quem>`,
+                leases: [],
+            });
+            continue;
+        }
+        const esperas = fila.filter((p) => p.thread === t.id);
+        if (esperas.length > 0) {
+            const p = esperas[0];
+            vagas.push({
+                thread: t.id,
+                slug: t.slug,
+                modo: t.modo,
+                fase: t.faseAtual,
+                situacao: 'espera',
+                motivo: 'lease.busy',
+                detalhe: `na fila de ${p.nome}, atras da thread ${p.bloqueadaPor} (colide com ${p.colidiuCom})`,
+                correcao: `espere a thread ${p.bloqueadaPor} liberar, ou reduza a regiao pedida`,
+                leases: [],
+            });
+            continue;
+        }
+        if (ocupadas >= max) {
+            vagas.push({
+                thread: t.id,
+                slug: t.slug,
+                modo: t.modo,
+                fase: t.faseAtual,
+                situacao: 'espera',
+                motivo: 'concurrency.limite',
+                detalhe: `a maquina ja tem ${ocupadas} thread(s) em andamento, o limite e ${max}`,
+                correcao: 'espere uma thread liberar, ou suba concurrency.max_parallel_threads no orkastery.yaml',
+                leases: [],
+            });
+            continue;
+        }
+        ocupadas += 1;
+        vagas.push({
+            thread: t.id,
+            slug: t.slug,
+            modo: t.modo,
+            fase: t.faseAtual,
+            situacao: 'pode-avancar',
+            motivo: null,
+            detalhe: `vaga ${ocupadas}/${max}, sem colisao de lease`,
+            correcao: '',
+            leases: [],
+        });
+    }
+    return {
+        maxParalelas: max,
+        emAndamento: emAndamento.size,
+        vagas,
+        filaDeMerge: (0, leases_1.esperandoPor)(raiz, leases_1.LEASE_MAIN_TREE),
+        filaDeRegiao: fila.filter((p) => p.tipo !== 'main-tree'),
+        decididoEm: (0, util_1.agora)(),
+    };
+}
+function linhaDeFila(p, i) {
+    return `  ${i + 1}. ${p.thread} quer ${p.nome} (colide com ${p.colidiuCom}, thread ${p.bloqueadaPor}) desde ${p.desdeEm}`;
+}
+/** Texto de `ork board plan`. */
+function textoDoPlano(plano) {
+    const linhas = [];
+    linhas.push('Escalonador por maquina');
+    linhas.push(`  limite de paralelismo: ${plano.maxParalelas} (concurrency.max_parallel_threads) | ` +
+        `em andamento agora: ${plano.emAndamento}`);
+    linhas.push('');
+    if (plano.vagas.length === 0) {
+        linhas.push('  Nenhuma thread no projeto.');
+    }
+    else {
+        linhas.push((0, util_1.tabela)(['THREAD', 'SLUG', 'MODO', 'FASE', 'SITUACAO', 'MOTIVO', 'DETALHE'], plano.vagas.map((v) => [
+            v.thread,
+            v.slug,
+            (0, modos_1.tagDoModo)(v.modo),
+            v.fase,
+            v.situacao,
+            v.motivo ?? '-',
+            v.detalhe,
+        ])));
+        const comCorrecao = plano.vagas.filter((v) => v.correcao !== '');
+        if (comCorrecao.length > 0) {
+            linhas.push('');
+            linhas.push('  Correcoes acionaveis:');
+            for (const v of comCorrecao)
+                linhas.push(`    ${v.thread}: ${v.correcao}`);
+        }
+    }
+    linhas.push('');
+    linhas.push(`Merge queue (lease ${leases_1.LEASE_MAIN_TREE}, o unico gate de merge)`);
+    if (plano.filaDeMerge.length === 0) {
+        linhas.push('  vazia: nenhuma thread esperando para mergear');
+    }
+    else {
+        plano.filaDeMerge.forEach((p, i) => linhas.push(linhaDeFila(p, i)));
+    }
+    linhas.push('');
+    linhas.push('Fila por colisao de regiao');
+    if (plano.filaDeRegiao.length === 0) {
+        linhas.push('  vazia: nenhuma colisao de path, board ou porta');
+    }
+    else {
+        plano.filaDeRegiao.forEach((p, i) => linhas.push(linhaDeFila(p, i)));
+    }
+    return linhas.join('\n');
+}
+/** Texto de `ork board [--all]`: a visao unica das threads. */
+function textoDoBoard(carregado, todos) {
+    const itens = threadsDeTodosOsPerfis(carregado, todos);
+    const perfis = todos ? perfisDetectados(carregado) : perfisDetectados(carregado).slice(0, 1);
+    const linhas = [];
+    linhas.push(`Board do Orkastery, projeto ${carregado.manifesto.project.name} ` +
+        `(${itens.length} thread(s) em ${perfis.length} perfil(is): ${perfis.map((p) => p.nome).join(', ')})`);
+    linhas.push('');
+    if (itens.length === 0) {
+        linhas.push('  Nenhuma thread ainda. Crie uma com: ork thread new "<nome>" --modo default');
+        return linhas.join('\n');
+    }
+    linhas.push((0, util_1.tabela)(['PERFIL', 'ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'PAUSAS', 'SCORE', 'WORKTREE', 'LEASES'], itens.map((i) => [
+        i.perfil,
+        i.thread.id,
+        i.thread.slug,
+        (0, modos_1.tagDoModo)(i.thread.modo),
+        i.thread.faseAtual,
+        i.thread.status,
+        String((0, thread_1.pausasDaThread)(i.thread)),
+        i.thread.score ? `${i.thread.score.valor}/5` : '-',
+        i.thread.worktree ? path.basename(i.thread.worktree) : '-',
+        i.leases.length > 0 ? i.leases.join(' ') : i.naFila.length > 0 ? `fila:${i.naFila[0].nome}` : '-',
+    ])));
+    const comVariante = itens.filter((i) => i.thread.variante);
+    if (comVariante.length > 0) {
+        linhas.push('');
+        linhas.push('  Variantes de ciclo em uso:');
+        for (const i of comVariante)
+            linhas.push(`    ${i.thread.id}: --ciclo ${i.thread.variante}`);
+    }
+    linhas.push('');
+    linhas.push(textoDoPlano(planejar(carregado)));
+    const semScore = itens.filter((i) => !i.thread.score && i.thread.faseAtual === 'MASTER');
+    if (semScore.length > 0) {
+        linhas.push('');
+        linhas.push(`Fila de batch scoring: ${semScore.length} thread(s) esperando score humano`);
+        linhas.push('  veja em: ork master --batch');
+    }
+    return linhas.join('\n');
+}

package/dist/canarios.js

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * Os 6 canarios de `ork eval` (bloco B4).
+ *
+ * Canario nao e teste unitario: e um comportamento inteiro do produto, exercitado ponta a
+ * ponta contra git de verdade, que precisa continuar acontecendo depois de qualquer mudanca.
+ * Cada um nasce de um jeito conhecido de o trabalho de um agente parecer certo e nao ser:
+ *
+ *   fx-happy         o ciclo que funciona, para o eval nao provar so o que quebra
+ *   fx-hallucination arquivo citado que nao existe: a alegacao reprova na reexecucao
+ *   fx-stale-base    a base andou embaixo da thread e o `ork` percebe antes do merge
+ *   fx-wiki-destroy  comando destrutivo em massa barrado pelo guard e pela policy
+ *   fx-schema-drift  o contrato congelado do MASTER log recusa mutacao
+ *   fx-concurrency   duas threads na mesma regiao: a segunda entra na fila, nao escreve
+ *
+ * A DIVISAO DE TRABALHO E DELIBERADA: o executor aqui e codigo tipado, e o que se espera dele
+ * e dado versionado em `eval/fixtures/<id>/caso.json`. Assim a expectativa e revisavel por
+ * quem nao le TypeScript, e mudar o comportamento esperado e um diff que aparece na revisao.
+ */
+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.gitDisponivel = exports.CANARIOS = void 0;
+exports.canarioPorId = canarioPorId;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const claims_1 = require("./claims");
+const leases_1 = require("./leases");
+const master_1 = require("./master");
+const policies_1 = require("./policies");
+const phase_1 = require("./phase");
+const sandbox_1 = require("./sandbox");
+Object.defineProperty(exports, "gitDisponivel", { enumerable: true, get: function () { return sandbox_1.gitDisponivel; } });
+const thread_1 = require("./thread");
+const verify_1 = require("./verify");
+const worktree_1 = require("./worktree");
+function comSandbox(nome, fn) {
+    const s = (0, sandbox_1.sandboxGit)(nome);
+    try {
+        return fn(s);
+    }
+    finally {
+        s.limpar();
+    }
+}
+/** fx-happy: o ciclo que funciona, do `thread new` ao `verify` verde. */
+const fxHappy = {
+    id: 'fx-happy',
+    sobre: 'thread aberta, fase montada com prompt gravado e claim verificada no HEAD real',
+    precisaDeGit: true,
+    rodar: () => comSandbox('happy', (s) => {
+        const { thread } = (0, thread_1.novaThread)(s.carregado, { nome: 'checkout', modo: 'ork' });
+        const corrida = (0, phase_1.rodarFase)(s.carregado, thread.id, {
+            fase: 'GOAL',
+            prompt: 'Mapear o objetivo do checkout',
+            dryRun: true,
+        });
+        (0, claims_1.adicionarClaim)(s.dir, thread.id, {
+            arquivo: 'README.md',
+            alegacao: 'o README do projeto existe e esta versionado',
+            verificar: ['test -f README.md'],
+            fase: 'GOAL',
+        });
+        const v = (0, verify_1.verificar)(s.carregado, thread.id, { soClaims: true });
+        return {
+            slug: thread.slug,
+            modo: thread.modo,
+            pausas: thread.blocos.filter((b) => b.pausa).length,
+            promptGravado: fs.existsSync(corrida.promptPath),
+            promptSha256Hex: /^[0-9a-f]{64}$/.test(corrida.promptSha256),
+            despachoBloqueado: corrida.bloqueado,
+            verifyOk: v.ok,
+            motivos: v.motivos,
+        };
+    }),
+};
+/** fx-hallucination: a citacao sem lastro reprova na reexecucao, com motivo tipado. */
+const fxHallucination = {
+    id: 'fx-hallucination',
+    sobre: 'arquivo e teste citados pelo agente que nao existem no repositorio',
+    precisaDeGit: true,
+    rodar: () => comSandbox('hallucination', (s) => {
+        const { thread } = (0, thread_1.novaThread)(s.carregado, { nome: 'alucinada', modo: 'auto' });
+        (0, claims_1.adicionarClaim)(s.dir, thread.id, {
+            arquivo: 'src/pagamentos.ts',
+            alegacao: 'implementei src/pagamentos.ts e o teste de pagamento passa',
+            verificar: ['test -f src/pagamentos.ts'],
+            fase: 'GO',
+        });
+        (0, claims_1.adicionarClaim)(s.dir, thread.id, {
+            arquivo: 'README.md',
+            alegacao: 'nao existe nenhum TODO em lugar nenhum do repositorio',
+            fase: 'GO',
+        });
+        const v = (0, verify_1.verificar)(s.carregado, thread.id, { soClaims: true });
+        return {
+            // O modo mais autonomo do espectro nao afrouxa a verificacao: `#Auto` reprova igual.
+            modo: thread.modo,
+            verifyOk: v.ok,
+            motivos: [...new Set(v.motivos)].sort(),
+            claimsReprovadas: v.claims.filter((c) => !c.verificado).length,
+        };
+    }),
+};
+/** fx-stale-base: a base andou embaixo da thread e o `ork` percebe antes do merge. */
+const fxStaleBase = {
+    id: 'fx-stale-base',
+    sobre: 'a branch base avancou depois de a thread carimbar a sua base',
+    precisaDeGit: true,
+    rodar: () => comSandbox('stalebase', (s) => {
+        const { thread } = (0, thread_1.novaThread)(s.carregado, {
+            nome: 'baseandou',
+            modo: 'classic',
+            criarWorktree: true,
+        });
+        (0, worktree_1.garantirWorktree)(s.carregado, thread.id);
+        const antes = (0, worktree_1.auditarWorktree)(s.carregado, thread.id);
+        (0, sandbox_1.commitar)(s.dir, 'MUDOU.md', '# a base andou\n', 'commit na base depois da thread');
+        const depois = (0, worktree_1.auditarWorktree)(s.carregado, thread.id);
+        const checkBase = depois.checks.find((c) => c.nome === 'base');
+        return {
+            auditavaAntes: antes.ok,
+            auditaDepois: depois.ok,
+            checkDaBase: checkBase ? checkBase.nivel : 'ausente',
+            correcao: checkBase?.correcao ?? '',
+        };
+    }),
+};
+/** fx-wiki-destroy: comando destrutivo em massa barrado no host e na entrega. */
+const fxWikiDestroy = {
+    id: 'fx-wiki-destroy',
+    sobre: 'agente tenta apagar trabalho alheio em massa, no host e na entrega',
+    precisaDeGit: false,
+    rodar: (ctx) => {
+        const guard = path.join(ctx.catalogo, 'adapters', 'claude-code', 'hooks', 'ork-guard.js');
+        const decidir = (comando) => {
+            const entrada = JSON.stringify({ tool_name: 'Bash', tool_input: { command: comando } });
+            try {
+                const saida = (0, node_child_process_1.execFileSync)(process.execPath, [guard], {
+                    input: entrada,
+                    encoding: 'utf8',
+                    // stderr capturado: o guard fala com o host, nao com a saida do `ork eval`.
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                return { decisao: JSON.parse(saida).hookSpecificOutput.permissionDecision, codigo: 0 };
+            }
+            catch (e) {
+                const erro = e;
+                const saida = JSON.parse(erro.stdout ?? '{}');
+                return {
+                    decisao: saida.hookSpecificOutput?.permissionDecision ?? 'sem-decisao',
+                    codigo: erro.status ?? -1,
+                };
+            }
+        };
+        // A outra metade do canario: a policy bloqueante do nucleo, que reprova entregar em cima
+        // da propria base. Guard do host e policy do nucleo sao defesas independentes de proposito.
+        const manifesto = {
+            runtime: { provider_policy: 'subscription-only' },
+            policies: { push_direto_na_base: 'block' },
+        };
+        const violacoes = (0, policies_1.avaliarPolicies)(manifesto, {
+            gate: 'ship',
+            de: 'main',
+            para: 'main',
+            baseBranch: 'main',
+        });
+        return {
+            gitAddEmMassa: decidir('git add -A').decisao,
+            codigoDoGitAdd: decidir('git add -A').codigo,
+            removeRecursivo: decidir('rm -rf $ALVO/').decisao,
+            resetDestrutivo: decidir('git reset --hard origin/main').decisao,
+            forcePush: decidir('git push --force origin main').decisao,
+            comandoDoOrkPassa: decidir('ork ship ork-x --para main').decisao,
+            addNomeadoPassa: decidir('git add -- src/pagamentos.ts').decisao,
+            policyDoShipBloqueia: (0, policies_1.bloqueantes)(violacoes).length,
+        };
+    },
+};
+/** fx-schema-drift: o contrato congelado do MASTER log recusa mutacao. */
+const fxSchemaDrift = {
+    id: 'fx-schema-drift',
+    sobre: 'MASTER log com contrato, escala ou catalogo de classes alterados',
+    precisaDeGit: false,
+    rodar: (ctx) => {
+        const caminho = path.join(ctx.catalogo, 'eval', 'fixtures', 'b2-master-log', 'caso.json');
+        const fixture = JSON.parse(fs.readFileSync(caminho, 'utf8'));
+        const erroDe = (mudanca) => (0, master_1.validarMasterLog)({ ...fixture.valido, ...mudanca }).length;
+        return {
+            validoPassa: (0, master_1.validarMasterLog)(fixture.valido).length === 0,
+            contratoTrocado: erroDe({ contrato: 'ork.master-log/v2' }) > 0,
+            scoreForaDaEscala: erroDe({ score: 7 }) > 0,
+            classeInventada: erroDe({ classesDeFalha: ['quase-deu-certo'] }) > 0,
+            faseForaDoCiclo: erroDe({ fases: ['GOAL', 'F7'] }) > 0,
+            justificativaVazia: erroDe({ justificativa: '' }) > 0,
+            evidenciaAusente: erroDe({ evidencia: { eventos: 0 } }) > 0,
+        };
+    },
+};
+/** fx-concurrency: duas threads na mesma regiao, a segunda entra na fila. */
+const fxConcurrency = {
+    id: 'fx-concurrency',
+    sobre: 'duas threads pedindo regiao que se cruza, com fila FIFO em vez de escrita por cima',
+    precisaDeGit: true,
+    rodar: () => comSandbox('concurrency', (s) => {
+        const a = (0, thread_1.novaThread)(s.carregado, { nome: 'primeira', modo: 'classic' }).thread;
+        const b = (0, thread_1.novaThread)(s.carregado, { nome: 'segunda', modo: 'maestro' }).thread;
+        const pedidoA = (0, leases_1.adquirirRegiao)(s.dir, 'path:core/src/**', {
+            thread: a.id,
+            motivo: 'GO da primeira',
+        });
+        const pedidoB = (0, leases_1.adquirirRegiao)(s.dir, 'path:core/src/board.ts', {
+            thread: b.id,
+            motivo: 'GO da segunda',
+        });
+        return {
+            primeiraAdquiriu: pedidoA.ok,
+            segundaAdquiriu: pedidoB.ok,
+            segundaNaFila: pedidoB.esperando,
+            posicaoDaSegunda: pedidoB.posicaoNaFila,
+            motivoDaSegunda: pedidoB.motivo,
+            colidiuComAThread: pedidoB.colidiuCom ? pedidoB.colidiuCom.thread : null,
+            threadDaPrimeira: a.id,
+        };
+    }),
+};
+/** Os canarios registrados, na ordem em que o `ork eval` os roda. */
+exports.CANARIOS = [
+    fxHappy,
+    fxHallucination,
+    fxStaleBase,
+    fxWikiDestroy,
+    fxSchemaDrift,
+    fxConcurrency,
+];
+/** Um canario por id, ou null quando a fixture aponta para um canario que nao existe. */
+function canarioPorId(id) {
+    return exports.CANARIOS.find((c) => c.id === id) ?? null;
+}