@orkastery/cli 0.2.0 → 0.4.1

package/dist/canarios-pulse.js

@@ -0,0 +1,147 @@
+"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.CANARIOS_PULSE = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_perf_hooks_1 = require("node:perf_hooks");
+const sandbox_1 = require("./sandbox");
+const thread_1 = require("./thread");
+const worktree_1 = require("./worktree");
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+const company_brain_journal_1 = require("./company-brain-journal");
+const node_crypto_1 = require("node:crypto");
+const hitl_gates_1 = require("./hitl-gates");
+const liveness_1 = require("./liveness");
+const hitl_1 = require("./hitl");
+const pulse_1 = require("./pulse");
+const orquestracao_1 = require("./orquestracao");
+const pulse_delivery_1 = require("./pulse-delivery");
+const catalogo_1 = require("./catalogo");
+exports.CANARIOS_PULSE = [
+    { id: 'fx-estado-dividido', sobre: '90 eventos na worktree não podem parecer 14 na main', precisaDeGit: true, rodar: () => {
+            const s = (0, sandbox_1.sandboxGit)('estado-dividido');
+            try {
+                const t = (0, thread_1.novaThread)(s.carregado, { nome: 'estado', modo: 'auto' }).thread, wt = (0, worktree_1.garantirWorktree)(s.carregado, t.id).dir;
+                const local = path.join(wt, '.orkastery/threads', t.id), main = (0, thread_1.dirThread)(s.dir, t.id);
+                fs.unlinkSync(local);
+                fs.mkdirSync(local);
+                const eventos = Array.from({ length: 90 }, (_, i) => JSON.stringify({ tipo: 'runtime_event', n: i }) + '\n');
+                fs.writeFileSync(path.join(main, 'ledger.jsonl'), eventos.slice(0, 14).join(''));
+                fs.writeFileSync(path.join(local, 'ledger.jsonl'), eventos.join(''));
+                const audit = (0, estado_thread_1.auditarEstado)(s.dir, t.id, wt), sync = (0, worktree_1.sincronizarWorktree)(s.carregado, t.id);
+                return { eventosMain: 14, eventosWorktree: 90, auditOk: audit.nivel === 'ok', syncOk: sync.ok,
+                    copiasPreservadas: fs.readFileSync(path.join(local, 'ledger.jsonl'), 'utf8') === eventos.join('') &&
+                        fs.readFileSync(path.join(main, 'ledger.jsonl'), 'utf8') === eventos.slice(0, 14).join('') };
+            }
+            finally {
+                s.limpar();
+            }
+        } },
+    { id: 'fx-fase-orfa', sobre: 'replay dos três despachos órfãos de 07/09/2026', precisaDeGit: true, rodar: ctx => {
+            const fixture = JSON.parse(fs.readFileSync(path.join(ctx.catalogo, 'eval/fixtures/fx-fase-orfa/caso.json'), 'utf8'));
+            const resultados = [];
+            for (const caso of fixture.replay) {
+                const s = (0, sandbox_1.sandboxGit)('replay-orfa');
+                try {
+                    const t = (0, thread_1.novaThread)(s.carregado, { nome: `replay fixture ${resultados.length + 1}`, modo: 'auto' }).thread;
+                    // I-41 (GO-FIX 1, D11): a decisao autonoma de 07/09 e linha HISTORICA, anterior ao rastro
+                    // tipado. O replay a reproduz como estava, sem passar pela exigencia da escrita nova, que e
+                    // exatamente a promessa de D11: evento antigo continua legivel, nenhuma linha e reescrita.
+                    for (const e of caso.eventos) {
+                        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma)
+                            (0, company_brain_journal_1.durableAppend)((0, ledger_1.caminhoLedger)((0, thread_1.dirThread)(s.dir, t.id)), { ...e, thread: t.id, eventId: (0, node_crypto_1.randomUUID)() });
+                        else
+                            (0, ledger_1.registrar)((0, thread_1.dirThread)(s.dir, t.id), t.id, e.tipo, { ...e, thread: t.id });
+                    }
+                    resultados.push(...(0, liveness_1.detectarFasesOrfas)(s.carregado, { quando: caso.consultaEm, fontes: () => ({}) }));
+                }
+                finally {
+                    s.limpar();
+                }
+            }
+            return { detectadas: resultados.length, latenciaMaxMin: Math.max(0, ...resultados.map(r => r.silencioHaMin)),
+                motivos: [...new Set(resultados.map(r => r.motivo))], automaticas: resultados.filter(r => r.retry.automatica).length,
+                precisamDeHumano: resultados.filter(r => !r.retry.automatica).length };
+        } },
+    { id: 'fx-hitl-latency', sobre: 'SIMULADO: alerta I-01 e resposta correlacionada via CLI até human_gate em menos de 60 s', precisaDeGit: true, rodar: ctx => {
+            const s = (0, sandbox_1.sandboxGit)('hitl-latency');
+            try {
+                const consulta = { ok: true, detalhe: '', sessoes: [{ id: 'fake', sessionId: 'fake', state: 'blocked', startedAt: Date.parse('2026-09-07T09:00:00Z') }] };
+                const casa = path.join(s.dir, 'host');
+                (0, hitl_1.varrerSessoes)({ raiz: s.dir, casa, consulta, semLogs: true, registrar: true, registrarMaquina: true, agora: '2026-09-07T10:01:00Z' });
+                const quando = '2026-09-07T10:05:00Z';
+                const radar = (0, hitl_1.varrerSessoes)({ raiz: s.dir, casa, consulta, semLogs: true, registrar: true, registrarMaquina: true, agora: quando });
+                const pulse = (0, pulse_1.comporPulse)(s.carregado, { radar, monitor: (0, orquestracao_1.montarMonitor)(s.carregado, { agora: quando, estados: new Map() }), batch: [], orfas: [] });
+                const sink = path.join(s.dir, 'sink.txt');
+                const config = { raiz: s.dir, quando, consultar: () => pulse, transporte: { executavel: process.execPath,
+                        argumentos: ['-e', 'require("fs").writeFileSync(process.argv[1],process.argv[2])', sink, '{{mensagem}}'] } };
+                const primeira = (0, pulse_delivery_1.varrerPulse)(config), segunda = (0, pulse_delivery_1.varrerPulse)(config);
+                // Medição real do caminho local, com identidade/chave exclusivamente SIMULADAS.
+                // Não mede Telegram nem atesta o ingresso nativo do gateway (T13).
+                const t = (0, thread_1.novaThread)(s.carregado, { nome: 'resposta simulada', modo: 'classic' }).thread;
+                (0, ledger_1.registrar)((0, thread_1.dirThread)(s.dir, t.id), t.id, 'phase_result', { fase: 'GOAL', evidencia: 'SIMULADO' });
+                const pedido = (0, hitl_gates_1.abrirPedidoGate)(s.dir, t.id);
+                const chave = 'canario-SIMULADO-sem-credencial-real-000';
+                const resposta = { origem: 'telegram', por: 'telegram:42', mensagem: 'telegram:-7:99',
+                    resposta: '1', recebidoEm: new Date().toISOString() };
+                const envelope = { ...resposta, prova: (0, hitl_gates_1.assinaturaDaResposta)(t.id, pedido.id, resposta, chave) };
+                const argv = [(0, catalogo_1.cliDoCatalogo)(ctx.catalogo), 'gate', 'answer', t.id, pedido.id,
+                    '--resposta-stdin', '--origem', 'telegram', '--por', resposta.por, '--mensagem', resposta.mensagem];
+                const ambiente = { ...process.env, ORK_HITL_INGRESS_KEY: chave, ORK_HITL_TELEGRAM_USERS: '42', ORK_HITL_TELEGRAM_CHATS: '-7' };
+                const enviar = (corpo) => (0, node_child_process_1.spawnSync)(process.execPath, argv, { cwd: s.dir, encoding: 'utf8',
+                    input: JSON.stringify(corpo), env: ambiente, timeout: 10000, maxBuffer: 65536 });
+                const inicio = node_perf_hooks_1.performance.now(), aceita = enviar(envelope);
+                const gate = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(s.dir, t.id)).find(e => e.tipo === 'human_gate');
+                const latenciaRespostaMs = node_perf_hooks_1.performance.now() - inicio;
+                const repetida = enviar(envelope), adulterada = enviar({ ...envelope, resposta: '2' });
+                return { latenciaMin: radar.sessoes[0].paradaHaMin, enviadas: primeira.enviadas, repetidas: segunda.enviadas,
+                    // I-41: o transporte recebe o RESUMO composto pelo nucleo, nao uma mensagem por item. A
+                    // sonda continua sendo "o texto composto chegou ao sink", e o cabecalho prova composicao
+                    // porque carrega a data-hora formatada no fuso do dono, nao uma constante do codigo.
+                    sinkRecebeu: fs.existsSync(sink) && fs.readFileSync(sink, 'utf8').includes('Orkastery, resumo de '),
+                    simulado: true, respostaRecebida: aceita.status === 0 && gate?.pedidoId === pedido.id && gate?.estado === 'aprovado',
+                    latenciaRespostaMs, respostaAbaixo60s: !!gate && aceita.status === 0 && latenciaRespostaMs < 60000,
+                    idempotente: repetida.status === 0 && JSON.parse(repetida.stdout).repetida === true &&
+                        (0, ledger_1.lerLedger)((0, thread_1.dirThread)(s.dir, t.id)).filter(e => e.tipo === 'human_gate').length === 1,
+                    adulteradaRecusada: adulterada.status !== 0, conteudoAusente: !!gate && gate.resposta === undefined && gate.prova === undefined };
+            }
+            finally {
+                s.limpar();
+            }
+        } },
+];

package/dist/canarios-sensores.js

@@ -0,0 +1,129 @@
+"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.CANARIO_SENSORES = void 0;
+/** T8: subprocessos, CLI e estado canônico reais; protocolo Codex sintético. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const sandbox_1 = require("./sandbox");
+const thread_1 = require("./thread");
+const ledger_1 = require("./ledger");
+const codex_runner_1 = require("./adapters/codex-runner");
+const session_watcher_1 = require("./session-watcher");
+const estado_thread_1 = require("./estado-thread");
+const catalogo_1 = require("./catalogo");
+const linha = (e) => JSON.stringify(e) + '\n';
+function esperar(teste) {
+    const limite = Date.now() + 5000;
+    while (!teste()) {
+        if (Date.now() >= limite)
+            throw new Error('subprocesso do canário não terminou em 5000 ms');
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+}
+exports.CANARIO_SENSORES = {
+    id: 'fx-sensores-runtime', sobre: 'hooks, supervisor e watcher integrados em sandbox Git', precisaDeGit: true,
+    rodar: ({ catalogo }) => {
+        const s = (0, sandbox_1.sandboxGit)('sensores-runtime');
+        try {
+            const t = (0, thread_1.novaThread)(s.carregado, { nome: 'sensores', modo: 'auto', criarWorktree: true }).thread;
+            const dir = (0, thread_1.dirThread)(s.dir, t.id), wt = t.worktree;
+            const iniciadoEm = new Date(Date.now() - 1000).toISOString();
+            const sessao = (sessionId, runtime) => {
+                t.sessoes.push({ sessionId, runtime, slug: t.slug, fase: 'GO', bloco: 'GO', despachadaEm: iniciadoEm,
+                    promptPath: '', promptSha256: '', verificada: true });
+                (0, thread_1.gravarThread)(s.dir, t);
+            };
+            sessao('fixture-claude', 'claude-bg');
+            const hook = path.join(catalogo, 'adapters/claude-code/hooks/ork-sensor.js');
+            const cli = (0, catalogo_1.cliDoCatalogo)(catalogo);
+            const start = Date.now();
+            const h = (0, node_child_process_1.spawnSync)(process.execPath, [hook], { cwd: wt, encoding: 'utf8', timeout: 5000,
+                input: JSON.stringify({ cwd: wt, session_id: 'fixture-claude', hook_event_name: 'PermissionRequest', tool_use_id: 'fixture-tool' }),
+                env: { ...process.env, ORK_SENSOR_CLI: cli } });
+            if (h.status !== 0 || h.stderr || h.stdout)
+                throw new Error('hook/CLI do canário indisponível');
+            const hookLatenciaMs = Date.now() - start;
+            const bloqueio = (0, ledger_1.lerLedger)(dir).find(e => e.tipo === 'sessao_bloqueada');
+            const carimboLatenciaMs = bloqueio ? Date.parse(String(bloqueio.recebidoEm)) - Date.parse(bloqueio.ts) : null;
+            const classificacoes = [];
+            let duplicatas = 0, subprocessosComRecibo = 0;
+            for (const [indice, mensagem] of ['Concluído.', 'Você confirma?', 'Motivo: lease.busy'].entries()) {
+                const sid = `fixture-codex-${indice}`;
+                sessao(sid, 'codex');
+                const log = path.join(dir, 'sessoes', `${sid}.jsonl`);
+                const protocolo = linha({ type: 'thread.started', thread_id: sid }) + linha({ type: 'turn.started' }) +
+                    linha({ type: 'turn.completed', last_agent_message: mensagem, usage: { input_tokens: 10, output_tokens: 2 } });
+                const metadados = (0, codex_runner_1.iniciarSupervisor)([process.execPath, '-e', 'process.stdout.write(process.argv[1])', protocolo], wt, log, process.env);
+                esperar(() => fs.existsSync(metadados.reciboPath));
+                subprocessosComRecibo++;
+                (0, ledger_1.registrar)(dir, t.id, 'session_sensor_registered', { sessionId: sid, despachoEm: iniciadoEm, logPath: log, ...metadados });
+                const r = (0, session_watcher_1.observarSessao)({ ...s.carregado, raiz: wt }, sid, { rollout: null });
+                classificacoes.push(r.classificacao ?? 'unavailable');
+                (0, session_watcher_1.observarSessao)({ ...s.carregado, raiz: wt }, sid, { rollout: null });
+                duplicatas += Math.abs((0, ledger_1.lerLedger)(dir).filter(e => e.tipo === 'phase_result' && e.sessionId === sid).length - 1);
+            }
+            // A identidade vem de um processo realmente executado e encerrado, sem recibo.
+            const runner = require.resolve('./adapters/codex-runner');
+            const morto = (0, node_child_process_1.spawnSync)(process.execPath, ['-e', `console.log(JSON.stringify(require(process.argv[1]).identidadeProcesso(process.pid)))`, runner], { cwd: wt, encoding: 'utf8', timeout: 5000 });
+            if (morto.status !== 0)
+                throw new Error('processo de morte do canário indisponível');
+            const filho = JSON.parse(morto.stdout);
+            if ((0, codex_runner_1.estadoProcesso)(filho) !== 'ausente')
+                throw new Error('processo ainda não está ausente');
+            const sid = 'fixture-morto';
+            sessao(sid, 'codex');
+            const log = path.join(dir, 'sessoes', `${sid}.jsonl`), inicio = Date.parse(iniciadoEm);
+            fs.writeFileSync(log, linha({ type: 'thread.started', thread_id: sid }));
+            fs.utimesSync(log, inicio / 1000, inicio / 1000);
+            const processo = { schema: 'ork.codex-process/v1', iniciadoEm, supervisor: (0, codex_runner_1.identidadeProcesso)(process.pid), filho };
+            fs.writeFileSync(log + '.process.json', JSON.stringify(processo));
+            (0, ledger_1.registrar)(dir, t.id, 'session_sensor_registered', { sessionId: sid, despachoEm: iniciadoEm, logPath: log, processoPath: log + '.process.json' });
+            const antes = (0, session_watcher_1.observarSessao)(s.carregado, sid, { rollout: null, agoraMs: inicio + session_watcher_1.LIMITE_MORTE_MS - 1 });
+            (0, session_watcher_1.observarSessao)(s.carregado, sid, { rollout: null, agoraMs: inicio + session_watcher_1.LIMITE_MORTE_MS });
+            const mortes = (0, ledger_1.lerLedger)(dir).filter(e => e.tipo === 'sessao_morta' && e.sessionId === sid);
+            return { tipoProva: 'harness isolado; protocolo Codex sintético', classificacoes, subprocessosComRecibo,
+                hookLatenciaMs, carimboLatenciaMs, hookAbaixo5s: !!bloqueio && hookLatenciaMs < 5000 && carimboLatenciaMs !== null && carimboLatenciaMs < 5000,
+                morteAntesDoLimite: antes.concluido, morteLatenciaMs: mortes[0]?.morteLatenciaMs ?? null,
+                mortosSemEvento: mortes.length === 1 ? 0 : 1, duplicatas,
+                estadoUnico: (0, estado_thread_1.auditarEstado)(s.dir, t.id, wt).nivel === 'ok' &&
+                    fs.realpathSync(path.join(wt, '.orkastery/threads', t.id)) === dir };
+        }
+        finally {
+            s.limpar();
+        }
+    },
+};

package/dist/canarios.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Os 6 canarios de `ork eval` (bloco B4).
+ * Os 7 canarios de `ork eval` (6 do bloco B4 + fx-codex-dry da homologacao do codex).
  *
  * 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.
@@ -61,11 +61,21 @@ const leases_1 = require("./leases");
 const master_1 = require("./master");
 const policies_1 = require("./policies");
 const phase_1 = require("./phase");
+const setup_1 = require("./setup");
 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");
+const canarios_pulse_1 = require("./canarios-pulse");
+const canarios_sensores_1 = require("./canarios-sensores");
+const canarios_hitl_1 = require("./canarios-hitl");
+const canarios_i43_1 = require("./canarios-i43");
+const objective_1 = require("./objective");
+const maestro_discovery_1 = require("./maestro-discovery");
+const maestro_cli_1 = require("./maestro-cli");
+const maestro_actions_1 = require("./maestro-actions");
+const ledger_1 = require("./ledger");
 function comSandbox(nome, fn) {
     const s = (0, sandbox_1.sandboxGit)(nome);
     try {
@@ -81,7 +91,7 @@ const fxHappy = {
     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 { thread } = (0, thread_1.novaThread)(s.carregado, { nome: 'checkout', modo: 'classic' });
         const corrida = (0, phase_1.rodarFase)(s.carregado, thread.id, {
             fase: 'GOAL',
             prompt: 'Mapear o objetivo do checkout',
@@ -256,6 +266,98 @@ const fxConcurrency = {
         };
     }),
 };
+/**
+ * fx-codex-dry: o runtime codex despacha pelo caminho real do setup, sem rede.
+ *
+ * Nasce da homologacao do segundo runtime (thread ork-homologarcod): um `setup.json`
+ * apontando o bloco para o codex tem de mudar o COMANDO que o despacho monta, e o
+ * default sem setup tem de continuar saindo pelo claude-bg byte a byte (paridade sem
+ * downgrade). Tudo em dry-run: canario nao gasta assinatura de ninguem.
+ */
+const fxCodexDry = {
+    id: 'fx-codex-dry',
+    sobre: 'setup do bloco levando o despacho ao codex, com o claude-bg intacto como padrao',
+    precisaDeGit: true,
+    rodar: () => comSandbox('codex-dry', (s) => {
+        const padrao = (0, thread_1.novaThread)(s.carregado, { nome: 'entrega padrao', modo: 'auto' }).thread;
+        const semSetup = (0, phase_1.rodarFase)(s.carregado, padrao.id, {
+            fase: 'GOAL',
+            prompt: 'Mapear o objetivo',
+            dryRun: true,
+        });
+        (0, setup_1.editarBloco)(s.dir, 'auto', 1, { runtime: 'codex', model: 'gpt-6-astra', effort: 'xhigh' });
+        const custom = (0, thread_1.novaThread)(s.carregado, { nome: 'entrega codex', modo: 'auto' }).thread;
+        const comSetup = (0, phase_1.rodarFase)(s.carregado, custom.id, {
+            fase: 'GOAL',
+            prompt: 'Mapear o objetivo',
+            dryRun: true,
+        });
+        return {
+            padraoRuntime: semSetup.runtime,
+            padraoComando: semSetup.comando[0],
+            codexRuntime: comSetup.runtime,
+            codexComando: comSetup.comando.slice(0, 2).join(' '),
+            codexModel: comSetup.model,
+            codexEffort: comSetup.effort,
+            codexHeadless: comSetup.comando[1] === 'app-server' && comSetup.comando.includes('--listen') && comSetup.comando.includes('stdio://'),
+            nadaDespachado: semSetup.dryRun && comSetup.dryRun,
+        };
+    }),
+};
+/** fx-objective-oscillation: revisões repetidas pausam o objetivo em vez de rodar para sempre. */
+const fxObjectiveOscillation = {
+    id: 'fx-objective-oscillation',
+    sobre: 'Objective Envelope revisado três vezes aciona a guarda de oscilação',
+    precisaDeGit: true,
+    rodar: () => comSandbox('objective-oscillation', (s) => {
+        let objective = (0, objective_1.createObjective)(s.carregado, { title: 'checkout premium', request: 'entregar valor', doneWhen: ['prova verde'] });
+        for (let revision = 1; revision <= 3; revision++)
+            objective = (0, objective_1.reviseObjective)(s.dir, objective.id, `entregar valor v${revision}`);
+        return {
+            threads: objective.threads.length,
+            revisions: objective.revisions,
+            state: objective.status,
+            reason: objective.pauseReason,
+            history: objective.envelopeHistory.length,
+            currentVersion: objective.envelope.version,
+        };
+    }),
+};
+/** Projeto temporário real; nenhum host/humano real é simulado como ativação live. */
+const fxMaestroBootstrap = {
+    id: 'fx-maestro-bootstrap',
+    sobre: 'SIMULADO: consulta limpa, ação com readback e policy block no modo Auto',
+    precisaDeGit: true,
+    rodar: () => comSandbox('maestro-bootstrap', s => {
+        const before = (0, thread_1.listarIds)(s.dir).length;
+        let raw = '';
+        const exit = (0, maestro_cli_1.runMaestroCli)(['--json'], s.dir, {}, { out: v => { raw = v; }, err: () => { } });
+        const clean = JSON.parse(raw);
+        const createsThread = (0, thread_1.listarIds)(s.dir).length !== before;
+        const t = (0, thread_1.novaThread)(s.carregado, { nome: 'Canário Maestro', modo: 'auto' }).thread;
+        const context = (0, maestro_discovery_1.discoverMaestro)({ cwd: s.dir });
+        const snapshot = () => (0, maestro_cli_1.readMaestro)(context, { host: { tools: ['ork_thread_status', 'ork_phase_run'], child: true } });
+        const state = snapshot();
+        let calls = 0;
+        const result = (0, maestro_actions_1.performMaestroAction)(context, { id: `thread.status:${t.id}`, expectedFingerprint: state.fingerprint }, {
+            snapshot, receipts: () => null, readback: id => (0, thread_1.lerThread)(s.dir, id),
+            operations: { 'thread.status': id => { calls++; return (0, thread_1.lerThread)(s.dir, id); } },
+        });
+        // A policy real corre antes do despacho e não grava o prompt sensível.
+        s.carregado.manifesto.policies = { segredo_em_prompt: 'block' };
+        const blocked = (0, phase_1.rodarFase)(s.carregado, t.id, { fase: 'GOAL', dryRun: true,
+            prompt: 'FIXTURE sintética ' + 'sk-ant-' + 'x'.repeat(24) });
+        const event = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(s.dir, t.id)).find(e => e.tipo === 'gate_blocked' && e.motivo === 'policy.violation');
+        return {
+            simulado: true, contract: clean.schema, queryExit: exit, createsThread,
+            childRedispatch: state.sections.nextActions.items.some(i => i.action?.operation === 'phase' && i.action.available),
+            actionCalls: calls, readbackMatches: result.readback.id === t.id && result.receipt.id === t.id,
+            autoPolicyBlocked: blocked.bloqueado && blocked.motivo === 'policy.violation' && !!event?.reprovaEmTodoModo,
+            noDispatch: !(0, ledger_1.lerLedger)((0, thread_1.dirThread)(s.dir, t.id)).some(e => e.tipo === 'phase_dispatch'),
+            promptNotWritten: !fs.existsSync(blocked.promptPath),
+        };
+    }),
+};
 /** Os canarios registrados, na ordem em que o `ork eval` os roda. */
 exports.CANARIOS = [
     fxHappy,
@@ -264,6 +366,13 @@ exports.CANARIOS = [
     fxWikiDestroy,
     fxSchemaDrift,
     fxConcurrency,
+    fxCodexDry,
+    fxObjectiveOscillation,
+    fxMaestroBootstrap,
+    ...canarios_pulse_1.CANARIOS_PULSE,
+    canarios_sensores_1.CANARIO_SENSORES,
+    ...canarios_hitl_1.CANARIOS_HITL,
+    ...canarios_i43_1.CANARIOS_I43,
 ];
 /** Um canario por id, ou null quando a fixture aponta para um canario que nao existe. */
 function canarioPorId(id) {

package/dist/catalogo.js

@@ -45,6 +45,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BUCKETS = void 0;
 exports.raizDoCatalogo = raizDoCatalogo;
 exports.exigirCatalogo = exigirCatalogo;
+exports.cliDoCatalogo = cliDoCatalogo;
 exports.skillsDoCatalogo = skillsDoCatalogo;
 exports.referenciasDoCatalogo = referenciasDoCatalogo;
 const fs = __importStar(require("node:fs"));
@@ -91,6 +92,14 @@ exports.BUCKETS = [
     'observability',
 ];
 /** Todas as skills do catalogo, varridas do disco (nunca de uma lista escrita a mao). */
+/**
+ * O CLI que um canario chama. No repositorio ele fica em `core/dist/`; no pacote npm o catalogo e
+ * a propria raiz do pacote e o CLI e o que esta rodando, ao lado deste arquivo compilado.
+ */
+function cliDoCatalogo(catalogo) {
+    const doRepositorio = path.join(catalogo, 'core', 'dist', 'index.js');
+    return fs.existsSync(doRepositorio) ? doRepositorio : path.join(__dirname, 'index.js');
+}
 function skillsDoCatalogo(raiz) {
     const achadas = [];
     for (const bucket of exports.BUCKETS) {