@orkastery/cli 0.2.0 → 0.4.1

package/dist/board.js

@@ -49,16 +49,27 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.perfisDetectados = perfisDetectados;
 exports.threadsDeTodosOsPerfis = threadsDeTodosOsPerfis;
+exports.estadosDeSessao = estadosDeSessao;
 exports.planejar = planejar;
+exports.devolverVagas = devolverVagas;
+exports.textoDoReap = textoDoReap;
 exports.textoDoPlano = textoDoPlano;
 exports.textoDoBoard = textoDoBoard;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const adapter = __importStar(require("./adapters/claude-bg"));
+const hitl_1 = require("./hitl");
 const leases_1 = require("./leases");
+const ledger_1 = require("./ledger");
 const manifest_1 = require("./manifest");
 const modos_1 = require("./modos");
+const ocupacao_1 = require("./ocupacao");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const sessoes_adopt_1 = require("./sessoes-adopt");
+const horario_1 = require("./horario");
+const conducao_1 = require("./conducao");
+const conducao_texto_1 = require("./conducao-texto");
 /**
  * Perfis detectados no projeto.
  *
@@ -95,34 +106,60 @@ function threadsDeTodosOsPerfis(carregado, todos = true) {
                 perfil: perfil.nome,
                 raiz: perfil.raiz,
                 thread,
-                leases: (0, leases_1.leasesDaThread)(perfil.raiz, id).map((l) => l.nome),
+                // I-36: a conducao (`exec:`) tem secao propria; o escalonador segue contando so os leases de escrita.
+                leases: (0, leases_1.leasesDaThread)(perfil.raiz, id).filter((l) => (0, leases_1.tipoDoLease)(l.nome) !== 'exec').map((l) => l.nome),
                 naFila: fila.filter((p) => p.thread === id),
             });
         }
     }
     return saida;
 }
+/** Estados de sessao do runtime, ou null quando ele nao pode ser consultado. */
+function estadosDeSessao() {
+    if (!adapter.disponivel())
+        return null;
+    return new Map(adapter
+        .listarSessoes()
+        .filter((s) => !!s.sessionId)
+        .map((s) => [s.sessionId, (0, hitl_1.estadoBruto)(s)]));
+}
 /**
  * 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.
+ * A vaga e OCUPACAO REAL, nao existencia de thread aberta (correcao do incidente de
+ * 06/09/2026): ocupa vaga quem tem procura ativa (`avaliarOcupacao`) ou quem segura
+ * lease sem estar travada. Pausa humana aberta, impedimento nao-transitorio e stale
+ * devolvem a vaga com motivo tipado, e a fila anda em FIFO por criacao da thread.
  */
-function planejar(carregado) {
+function planejar(carregado, opcoes = {}) {
     const { raiz, manifesto } = carregado;
     const max = Math.max(1, manifesto.concurrency.max_parallel_threads);
+    const staleMin = manifesto.concurrency.stale_after_min;
+    const quando = opcoes.agora ?? (0, util_1.agora)();
+    const estados = opcoes.estados === undefined ? estadosDeSessao() : opcoes.estados;
     const fila = (0, leases_1.lerFila)(raiz);
-    const ativos = (0, leases_1.listarLeases)(raiz).filter((l) => !(0, leases_1.expirado)(l));
+    // I-36: a conducao (`exec:`) nao entra na conta de vagas: a ocupacao da sessao ja sai do ledger
+    // e do runtime (`avaliarOcupacao`), e conta-la de novo mudaria o escalonador.
+    const ativos = (0, leases_1.listarLeases)(raiz).filter((l) => !(0, leases_1.expirado)(l) && (0, leases_1.tipoDoLease)(l.nome) !== 'exec');
     const threads = (0, thread_1.listarIds)(raiz)
         .map((id) => (0, thread_1.lerThread)(raiz, id))
         .sort((a, b) => a.criadaEm.localeCompare(b.criadaEm));
+    const ocupacoes = new Map(threads.map((t) => [
+        t.id,
+        (0, ocupacao_1.avaliarOcupacao)(t, (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id)), { agora: quando, estados, staleMin }),
+    ]));
     const vagas = [];
     let ocupadas = 0;
-    // 1a passada: quem ja segura lease esta em andamento e ocupa vaga.
+    // 1a passada: quem tem procura ativa esta em andamento e ocupa vaga. Segurar lease
+    // sem estar travada tambem ocupa: o lease e trabalho em curso na regiao protegida.
     const emAndamento = new Set();
     for (const t of threads) {
+        if (t.status === 'fechada' || (0, sessoes_adopt_1.ehRegistroDeAdocao)(t))
+            continue;
+        const oc = ocupacoes.get(t.id);
         const meus = ativos.filter((l) => l.thread === t.id).map((l) => l.nome);
-        if (t.status === 'fechada' || meus.length === 0)
+        const ocupa = oc.ocupaVaga || (meus.length > 0 && oc.classe === 'ociosa');
+        if (!ocupa)
             continue;
         emAndamento.add(t.id);
         ocupadas += 1;
@@ -133,15 +170,17 @@ function planejar(carregado) {
             fase: t.faseAtual,
             situacao: 'em-andamento',
             motivo: null,
-            detalhe: `segura ${meus.join(', ')}`,
+            detalhe: meus.length > 0 ? `segura ${meus.join(', ')}; ${oc.detalhe}` : oc.detalhe,
             correcao: '',
             leases: meus,
         });
     }
-    // 2a passada: as demais, em FIFO, ate o limite de paralelismo da maquina.
+    // 2a passada: as demais, em FIFO. Thread travada (pausa humana, impedimento, stale)
+    // NAO ocupa vaga: e exatamente a thread orfa que sufocava as demandas legitimas.
     for (const t of threads) {
         if (emAndamento.has(t.id))
             continue;
+        const meus = ativos.filter((l) => l.thread === t.id).map((l) => l.nome);
         if (t.status === 'fechada') {
             vagas.push({
                 thread: t.id,
@@ -156,7 +195,15 @@ function planejar(carregado) {
             });
             continue;
         }
-        if (t.status === 'pausada') {
+        const oc = ocupacoes.get(t.id);
+        if ((0, sessoes_adopt_1.ehRegistroDeAdocao)(t)) {
+            vagas.push({ thread: t.id, slug: t.slug, modo: t.modo, fase: t.faseAtual,
+                situacao: oc.classe === 'pausa-humana' ? 'pausada' : 'espera',
+                motivo: oc.motivo, detalhe: 'registro de adoção: identidade preservada, sem trabalho a despachar',
+                correcao: oc.classe === 'pausa-humana' ? 'ork sessions hitl' : '', leases: meus });
+            continue;
+        }
+        if (oc.classe === 'pausa-humana') {
             vagas.push({
                 thread: t.id,
                 slug: t.slug,
@@ -164,9 +211,38 @@ function planejar(carregado) {
                 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: [],
+                detalhe: oc.detalhe,
+                correcao: `ork gate request ${t.id}`,
+                leases: meus,
+            });
+            continue;
+        }
+        if (oc.classe === 'impedida') {
+            vagas.push({
+                thread: t.id,
+                slug: t.slug,
+                modo: t.modo,
+                fase: t.faseAtual,
+                situacao: 'espera',
+                motivo: oc.motivo,
+                detalhe: oc.detalhe,
+                correcao: `ork retry plan ${t.id} --motivo ${String(oc.motivo)}, ou feche com ork master ${t.id}`,
+                leases: meus,
+            });
+            continue;
+        }
+        if (oc.classe === 'stale') {
+            vagas.push({
+                thread: t.id,
+                slug: t.slug,
+                modo: t.modo,
+                fase: t.faseAtual,
+                situacao: 'espera',
+                motivo: 'vaga.stale',
+                detalhe: oc.detalhe,
+                correcao: `redespache com ork phase run ${t.id} --fase ${t.faseAtual}, ` +
+                    `ou feche com ork master ${t.id}`,
+                leases: meus,
             });
             continue;
         }
@@ -219,18 +295,85 @@ function planejar(carregado) {
         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)(),
+        decididoEm: quando,
     };
 }
-function linhaDeFila(p, i) {
-    return `  ${i + 1}. ${p.thread} quer ${p.nome} (colide com ${p.colidiuCom}, thread ${p.bloqueadaPor}) desde ${p.desdeEm}`;
+/**
+ * `ork board reap`: grava no ledger de cada thread SEM procura ativa o evento
+ * `slot_released`, com quem decidiu, evidencia e razao.
+ *
+ * A vaga em si e derivada (o `planejar` ja a devolve sozinho a cada decisao); o reap
+ * existe para a devolucao virar EVENTO VERIFICAVEL no ledger da thread devolvida.
+ * Ele e idempotente: enquanto um `slot_released` estiver aberto (sem evento posterior
+ * que destrave a thread), rodar de novo nao grava linha nova.
+ */
+function devolverVagas(carregado, opcoes = {}) {
+    const { raiz, manifesto } = carregado;
+    const staleMin = manifesto.concurrency.stale_after_min;
+    const quando = opcoes.agora ?? (0, util_1.agora)();
+    const estados = opcoes.estados === undefined ? estadosDeSessao() : opcoes.estados;
+    const quem = opcoes.por ?? 'escalonador (ork board reap)';
+    const devolvidas = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        const t = (0, thread_1.lerThread)(raiz, id);
+        if (t.status === 'fechada' || (0, sessoes_adopt_1.ehRegistroDeAdocao)(t))
+            continue;
+        const dir = (0, thread_1.dirThread)(raiz, id);
+        const eventos = (0, ledger_1.lerLedger)(dir);
+        const oc = (0, ocupacao_1.avaliarOcupacao)(t, eventos, { agora: quando, estados, staleMin });
+        if (oc.classe !== 'pausa-humana' && oc.classe !== 'impedida' && oc.classe !== 'stale') {
+            continue;
+        }
+        const jaRegistrada = eventos.some((e, i) => e.tipo === ledger_1.TIPOS_DE_EVENTO.vagaLiberada &&
+            !eventos
+                .slice(i + 1)
+                .some((p) => ocupacao_1.EVENTOS_QUE_DESTRAVAM.includes(p.tipo) || (0, ocupacao_1.ehAprovacaoHumana)(p)));
+        if (!jaRegistrada) {
+            (0, ledger_1.registrar)(dir, id, ledger_1.TIPOS_DE_EVENTO.vagaLiberada, {
+                fase: t.faseAtual,
+                motivo: oc.motivo,
+                quem,
+                detalhe: oc.detalhe,
+                evidencia: oc.evidencia,
+                razao: 'thread sem procura ativa nao ocupa vaga de concurrency.max_parallel_threads: ' +
+                    'a vaga volta para as threads prontas para rodar',
+            });
+        }
+        devolvidas.push({
+            thread: id,
+            classe: oc.classe,
+            motivo: oc.motivo,
+            detalhe: oc.detalhe,
+            evidencia: oc.evidencia,
+            registrada: !jaRegistrada,
+        });
+    }
+    return devolvidas;
+}
+/** Texto de `ork board reap`. */
+function textoDoReap(devolvidas) {
+    if (devolvidas.length === 0) {
+        return 'Nenhuma vaga a devolver: toda thread aberta tem procura ativa ou esta pronta para rodar.';
+    }
+    // I-35: o ledger guarda o ISO; o texto ao dono sai no fuso dele, rotulado uma vez.
+    const linhas = [`Vagas devolvidas por falta de procura ativa: ${devolvidas.length}. ${(0, horario_1.legendaDoFuso)()}`, ''];
+    for (const d of devolvidas) {
+        const marca = d.registrada ? 'slot_released gravado no ledger' : 'ja registrado antes (idempotente)';
+        linhas.push(`  ${d.thread.padEnd(20)} [${d.motivo}] ${marca}`);
+        linhas.push(`    detalhe  : ${(0, horario_1.localizarTexto)(d.detalhe)}`);
+        linhas.push(`    evidencia: ${(0, horario_1.localizarTexto)(d.evidencia)}`);
+    }
+    return linhas.join('\n');
+}
+function linhaDeFila(p, i, agora) {
+    return `  ${i + 1}. ${p.thread} quer ${p.nome} (colide com ${p.colidiuCom}, thread ${p.bloqueadaPor}) desde ${(0, horario_1.formatarDesde)(p.desdeEm, { agora })}`;
 }
 /** Texto de `ork board plan`. */
 function textoDoPlano(plano) {
     const linhas = [];
-    linhas.push('Escalonador por maquina');
+    linhas.push(`Escalonador por maquina. ${(0, horario_1.legendaDoFuso)(undefined, plano.decididoEm)}`);
     linhas.push(`  limite de paralelismo: ${plano.maxParalelas} (concurrency.max_parallel_threads) | ` +
-        `em andamento agora: ${plano.emAndamento}`);
+        `em andamento agora (procura ativa): ${plano.emAndamento}`);
     linhas.push('');
     if (plano.vagas.length === 0) {
         linhas.push('  Nenhuma thread no projeto.');
@@ -243,14 +386,14 @@ function textoDoPlano(plano) {
             v.fase,
             v.situacao,
             v.motivo ?? '-',
-            v.detalhe,
+            (0, horario_1.localizarTexto)(v.detalhe, { agora: plano.decididoEm }),
         ])));
         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(`    ${v.thread}: ${(0, horario_1.localizarTexto)(v.correcao, { agora: plano.decididoEm })}`);
         }
     }
     linhas.push('');
@@ -259,7 +402,7 @@ function textoDoPlano(plano) {
         linhas.push('  vazia: nenhuma thread esperando para mergear');
     }
     else {
-        plano.filaDeMerge.forEach((p, i) => linhas.push(linhaDeFila(p, i)));
+        plano.filaDeMerge.forEach((p, i) => linhas.push(linhaDeFila(p, i, plano.decididoEm)));
     }
     linhas.push('');
     linhas.push('Fila por colisao de regiao');
@@ -267,7 +410,7 @@ function textoDoPlano(plano) {
         linhas.push('  vazia: nenhuma colisao de path, board ou porta');
     }
     else {
-        plano.filaDeRegiao.forEach((p, i) => linhas.push(linhaDeFila(p, i)));
+        plano.filaDeRegiao.forEach((p, i) => linhas.push(linhaDeFila(p, i, plano.decididoEm)));
     }
     return linhas.join('\n');
 }
@@ -295,6 +438,14 @@ function textoDoBoard(carregado, todos) {
         i.thread.worktree ? path.basename(i.thread.worktree) : '-',
         i.leases.length > 0 ? i.leases.join(' ') : i.naFila.length > 0 ? `fila:${i.naFila[0].nome}` : '-',
     ])));
+    // I-36 (T17): quem conduz cada thread agora, pela leitura unica do nucleo.
+    const conduzidas = itens.map((i) => ({ id: i.thread.id, c: (0, conducao_1.conducaoDaThread)(i.raiz, i.thread.id) })).filter((x) => x.c);
+    if (conduzidas.length > 0) {
+        linhas.push('');
+        linhas.push('Conducao agora');
+        for (const x of conduzidas)
+            linhas.push(`  ${x.id}: ${(0, conducao_texto_1.linhaDeConducao)(x.c)}`);
+    }
     const comVariante = itens.filter((i) => i.thread.variante);
     if (comVariante.length > 0) {
         linhas.push('');
@@ -308,7 +459,7 @@ function textoDoBoard(carregado, todos) {
     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');
+        linhas.push('  veja em: ork master (com o indice derivado do ledger)');
     }
     return linhas.join('\n');
 }

package/dist/branch-de-estado.js

@@ -0,0 +1,136 @@
+"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.refRemota = void 0;
+exports.git = git;
+exports.exigirGit = exigirGit;
+exports.pontaLocal = pontaLocal;
+exports.buscarBranch = buscarBranch;
+exports.jsonsDaPonta = jsonsDaPonta;
+exports.gravarNaBranch = gravarNaBranch;
+/**
+ * I-51 (RM-047): uma branch de estado compartilhada entre maquinas, fora da `main` e sem PR.
+ *
+ * Nasceu nas reservas do roadmap (I-47) e agora serve tambem ao estado da fabrica. Nada aqui toca
+ * a arvore de trabalho nem o indice do repositorio: blobs, arvore e commit sao montados com um
+ * indice temporario, e a branch local nunca e criada.
+ *
+ * A atomicidade vem do proprio git: a versao nova e um commit em cima da ponta lida, e o push
+ * nunca e forcado. Push recusado volta `false`, e quem chamou rele a ponta e aplica a propria
+ * regra de novo sobre o estado novo.
+ *
+ * `prefixo` da nome aos erros de quem usa (`roadmap.git`, `fabrica.sem-remoto`...).
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+function git(raiz, args, extra = {}) {
+    const r = (0, node_child_process_1.spawnSync)('git', args, { cwd: raiz, encoding: 'utf8', input: extra.input, timeout: extra.timeoutMs ?? 60000,
+        env: { ...process.env, ...extra.env } });
+    return { ok: r.status === 0, stdout: (r.stdout ?? '').toString(), stderr: (r.stderr ?? '').toString() };
+}
+function exigirGit(raiz, args, prefixo, extra = {}) {
+    const r = git(raiz, args, extra);
+    if (!r.ok)
+        throw new Error(`${prefixo}.git: git ${args[0]} falhou: ${r.stderr.trim().split('\n').pop() ?? ''}`);
+    return r.stdout;
+}
+const refRemota = (remoto, branch) => `refs/remotes/${remoto}/${branch}`;
+exports.refRemota = refRemota;
+/** A ultima copia lida da branch nesta maquina, sem rede. `null` quando nunca foi lida. */
+function pontaLocal(raiz, remoto, branch) {
+    const local = git(raiz, ['rev-parse', '--verify', '--quiet', (0, exports.refRemota)(remoto, branch)]);
+    return local.ok ? local.stdout.trim() : null;
+}
+/**
+ * Traz a ponta da branch. `ponta: null` quando ela ainda nao existe no remoto; sem rede, a ultima
+ * copia local com `atualizado: false`.
+ */
+function buscarBranch(raiz, remoto, branch, prefixo, timeoutMs) {
+    const r = git(raiz, ['fetch', '--quiet', '--no-tags', remoto, `+refs/heads/${branch}:${(0, exports.refRemota)(remoto, branch)}`], { timeoutMs });
+    if (r.ok)
+        return { ponta: exigirGit(raiz, ['rev-parse', '--verify', (0, exports.refRemota)(remoto, branch)], prefixo).trim(), atualizado: true };
+    if (/couldn't find remote ref|could not find remote ref/i.test(r.stderr)) {
+        // A branch ainda nao nasceu: a primeira gravacao a cria. Copia local antiga nao vale mais.
+        git(raiz, ['update-ref', '-d', (0, exports.refRemota)(remoto, branch)]);
+        return { ponta: null, atualizado: true };
+    }
+    return { ponta: pontaLocal(raiz, remoto, branch), atualizado: false };
+}
+/** Os `.json` de um diretorio da ponta, ja lidos. Filtro por caminho: diretorio vazio some da arvore. */
+function jsonsDaPonta(raiz, ponta, dir, prefixo) {
+    if (!ponta)
+        return [];
+    const caminhos = exigirGit(raiz, ['ls-tree', '-r', '--name-only', ponta, '--', `${dir}/`], prefixo)
+        .split('\n').filter((n) => n.endsWith('.json'));
+    return caminhos.map((c) => JSON.parse(exigirGit(raiz, ['show', `${ponta}:${c}`], prefixo)));
+}
+/**
+ * Grava uma versao nova da branch em cima de `ponta`, sem tocar arvore de trabalho nem indice:
+ * indice temporario, blobs, `write-tree` e `commit-tree`. Push sem forca; recusa volta `false`.
+ */
+function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo) {
+    const indice = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'ork-branch-estado-')), 'index');
+    const env = { GIT_INDEX_FILE: indice };
+    try {
+        if (ponta)
+            exigirGit(raiz, ['read-tree', ponta], prefixo, { env });
+        else
+            exigirGit(raiz, ['read-tree', '--empty'], prefixo, { env });
+        for (const m of mudancas) {
+            if (m.conteudo === null) {
+                exigirGit(raiz, ['update-index', '--force-remove', m.caminho], prefixo, { env });
+            }
+            else {
+                const blob = exigirGit(raiz, ['hash-object', '-w', '--stdin'], prefixo, { input: m.conteudo }).trim();
+                exigirGit(raiz, ['update-index', '--add', '--cacheinfo', `100644,${blob},${m.caminho}`], prefixo, { env });
+            }
+        }
+        const arvore = exigirGit(raiz, ['write-tree'], prefixo, { env }).trim();
+        const commit = exigirGit(raiz, ['commit-tree', arvore, ...(ponta ? ['-p', ponta] : []), '-m', mensagem], prefixo).trim();
+        const push = git(raiz, ['push', '--quiet', remoto, `${commit}:refs/heads/${branch}`]);
+        if (push.ok) {
+            git(raiz, ['update-ref', (0, exports.refRemota)(remoto, branch), commit]);
+            return commit;
+        }
+        if (/rejected|non-fast-forward|fetch first|stale info|failed to push/i.test(push.stderr))
+            return false;
+        throw new Error(`${prefixo}.sem-remoto: o push para ${remoto} falhou: ${push.stderr.trim().split('\n').pop() ?? ''}`);
+    }
+    finally {
+        fs.rmSync(path.dirname(indice), { recursive: true, force: true });
+    }
+}

package/dist/canarios-hitl.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANARIOS_HITL = void 0;
+const sandbox_1 = require("./sandbox");
+const thread_1 = require("./thread");
+const ledger_1 = require("./ledger");
+const gates_1 = require("./gates");
+const hitl_gates_1 = require("./hitl-gates");
+const pulse_1 = require("./pulse");
+const hitl_gates_2 = require("./hitl-gates");
+const hitl_gates_3 = require("./hitl-gates");
+const hitl_local_atestado_1 = require("./hitl-local-atestado");
+const hitl_canais_1 = require("./hitl-canais");
+exports.CANARIOS_HITL = [
+    { id: 'fx-blanket-approve', sobre: 'SIMULADO: aprovação cega e envelope sem autenticação são recusados', precisaDeGit: true, rodar: () => {
+            const s = (0, sandbox_1.sandboxGit)('blanket-approve');
+            try {
+                let recusas = 0, humanos = 0;
+                for (const modo of ['classic']) {
+                    const t = (0, thread_1.novaThread)(s.carregado, { nome: modo, modo }).thread;
+                    (0, ledger_1.registrar)((0, thread_1.dirThread)(s.dir, t.id), t.id, 'phase_result', { fase: 'GOAL' });
+                    const p = (0, hitl_gates_1.abrirPedidoGate)(s.dir, t.id);
+                    try {
+                        (0, gates_1.aprovarGateHumano)(s.dir, t.id, 'push', 'modelo');
+                    }
+                    catch {
+                        recusas++;
+                    }
+                    try {
+                        (0, hitl_gates_1.responderGate)(s.dir, t.id, p.id, { origem: 'telegram', por: 'telegram:42', mensagem: 'telegram:-7:1',
+                            recebidoEm: new Date().toISOString(), resposta: '1', prova: '0'.repeat(64) });
+                    }
+                    catch {
+                        recusas++;
+                    }
+                    humanos += (0, ledger_1.lerLedger)((0, thread_1.dirThread)(s.dir, t.id)).filter(e => e.tipo === 'human_gate').length;
+                }
+                return { simulado: true, recusas, humanos };
+            }
+            finally {
+                s.limpar();
+            }
+        } },
+    { id: 'fx-auto-quiet', sobre: 'SIMULADO: Auto/Maestro silenciosos fora de pausas; policy bloqueia', precisaDeGit: true, rodar: () => {
+            const s = (0, sandbox_1.sandboxGit)('auto-quiet');
+            try {
+                let pedidosRecusados = 0;
+                for (const modo of ['auto', 'maestro']) {
+                    const t = (0, thread_1.novaThread)(s.carregado, { nome: modo, modo }).thread;
+                    // Registro histórico incorreto não se sobrepõe ao contrato do modo corrente.
+                    (0, ledger_1.registrar)((0, thread_1.dirThread)(s.dir, t.id), t.id, 'human_gate', { fase: 'GOAL', estado: 'prevista ao fim do bloco' });
+                    try {
+                        (0, hitl_gates_1.abrirPedidoGate)(s.dir, t.id);
+                    }
+                    catch {
+                        pedidosRecusados++;
+                    }
+                }
+                const consulta = { ok: true, sessoes: [], detalhe: 'runtime SIMULADO' };
+                const antes = (0, pulse_1.montarPulse)(s.carregado, { consulta }).resumo.humanos;
+                const t = (0, thread_1.novaThread)(s.carregado, { nome: 'policy', modo: 'auto' }).thread;
+                (0, ledger_1.registrar)((0, thread_1.dirThread)(s.dir, t.id), t.id, 'gate_blocked', { fase: 'GOAL', motivo: 'policy.violation' });
+                const depois = (0, pulse_1.montarPulse)(s.carregado, { consulta });
+                return { simulado: true, pedidosRecusados, humanosSemEscalacao: antes,
+                    policyPreservada: depois.precisaDeHumanoAgora.some(i => i.thread === t.id && i.motivo === 'policy.violation') };
+            }
+            finally {
+                s.limpar();
+            }
+        } },
+    // O transporte de cada canal tem teste proprio; aqui o alvo e o RECIBO: os quatro
+    // precisam responder e ficar distinguiveis depois, que e o que D12 exige.
+    { id: 'fx-omnicanal', sobre: 'SIMULADO: os quatro canais respondem e ficam distinguiveis no recibo', precisaDeGit: true, rodar: () => {
+            const s = (0, sandbox_1.sandboxGit)('omnicanal');
+            // FX1: cada canal de telegram tem a SUA chave; o canario nunca compartilha segredo.
+            const nomes = ['ORK_HITL_INGRESS_KEY_HERMES', 'ORK_HITL_INGRESS_KEY_OPENCLAW',
+                'ORK_HITL_OPENCLAW_ACCOUNT', 'ORK_HITL_TELEGRAM_USERS', 'ORK_HITL_TELEGRAM_CHATS',
+                'ORK_HITL_ROOT', 'ORK_HITL_TELEGRAM_BOT_ID'];
+            const antigos = nomes.map(n => process.env[n]);
+            const chaves = { hermes: 'chave-SIMULADA-do-canario-hermes-00000000',
+                openclaw: 'chave-SIMULADA-do-canario-openclaw-000000' };
+            // FX5: so o OpenClaw tem conta homologada, e ela entra no corpo assinado.
+            const conta = 'conta-SIMULADA-do-canario-openclaw';
+            [chaves.hermes, chaves.openclaw, conta, '42', '-7', '/tmp/ork-hitl-canario', '999']
+                .forEach((v, i) => { process.env[nomes[i]] = v; });
+            try {
+                const registro = (0, hitl_canais_1.conferirRegistro)();
+                // Um gate por canal: a mensagem do Telegram nao se repete entre pedidos.
+                const gate = (nome) => {
+                    const t = (0, thread_1.novaThread)(s.carregado, { nome, modo: 'classic' }).thread;
+                    (0, ledger_1.registrar)((0, thread_1.dirThread)(s.dir, t.id), t.id, 'phase_result', { fase: 'GOAL' });
+                    return { t, pedido: (0, hitl_gates_1.abrirPedidoGate)(s.dir, t.id) };
+                };
+                const recibos = {};
+                for (const canal of ['hermes', 'openclaw']) {
+                    const { t, pedido } = gate(canal);
+                    const base = { resposta: '1', origem: 'telegram', canal, por: 'telegram:42',
+                        mensagem: `telegram:-7:${canal}`, recebidoEm: new Date().toISOString(),
+                        ...(canal === 'openclaw' ? { conta } : {}) };
+                    (0, hitl_gates_1.responderGate)(s.dir, t.id, pedido.id, { ...base, prova: (0, hitl_gates_1.assinaturaDaResposta)(t.id, pedido.id, base, chaves[canal]) });
+                    recibos[canal] = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(s.dir, t.id)).find(e => e.tipo === 'human_gate');
+                }
+                for (const canal of ['claude-code', 'codex']) {
+                    const { t, pedido } = gate(canal);
+                    // Atestado da conexao, como o servidor MCP emite depois de uma elicitation viva.
+                    const token = Object.freeze({});
+                    (0, hitl_local_atestado_1.registrarAtestadoLocal)(token, { raiz: s.dir, thread: t.id, pedidoId: pedido.id,
+                        contexto: (0, hitl_gates_3.contextoHitl)(s.dir, t.id), pedidoSha256: (0, hitl_local_atestado_1.hashPedidoLocal)(pedido), host: canal,
+                        connectionId: `conn-${canal}`, requestId: `req-${canal}`, opcao: '1',
+                        recebidoEm: new Date().toISOString(), alvo: 'gate' });
+                    (0, hitl_gates_2.responderGateLocal)(s.dir, t.id, pedido.id, token);
+                    recibos[canal] = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(s.dir, t.id)).find(e => e.tipo === 'human_gate');
+                }
+                // Os quatro responderam, e o recibo de cada um nomeia o seu canal.
+                const canais = (0, hitl_canais_1.canaisHomologados)().map(c => c.canal);
+                const aprovados = canais.filter(c => recibos[c]?.estado === 'aprovado');
+                const lidos = canais.map(c => (0, hitl_canais_1.canalDaResposta)((recibos[c] ?? {})).canal);
+                // Recusas: aprovacao cega, ingresso nao homologado e canal de outro transporte.
+                let recusas = 0;
+                const { t: tr, pedido: pr } = gate('recusas');
+                try {
+                    (0, gates_1.aprovarGateHumano)(s.dir, tr.id, 'push', 'modelo');
+                }
+                catch {
+                    recusas++;
+                }
+                try {
+                    (0, hitl_canais_1.recusarIngressoNaoHomologado)('transcrito-de-tool');
+                }
+                catch {
+                    recusas++;
+                }
+                const trocado = { resposta: '1', origem: 'telegram', canal: 'codex',
+                    por: 'telegram:42', mensagem: 'telegram:-7:trocado', recebidoEm: new Date().toISOString() };
+                try {
+                    (0, hitl_gates_1.responderGate)(s.dir, tr.id, pr.id, { ...trocado, prova: (0, hitl_gates_1.assinaturaDaResposta)(tr.id, pr.id, trocado, chaves.hermes) });
+                }
+                catch {
+                    recusas++;
+                }
+                // FX1: chave de um canal nao autentica envelope do outro, mesmo com tudo mais correto.
+                const cruzado = { resposta: '1', origem: 'telegram', canal: 'openclaw', conta,
+                    por: 'telegram:42', mensagem: 'telegram:-7:cruzado', recebidoEm: new Date().toISOString() };
+                try {
+                    (0, hitl_gates_1.responderGate)(s.dir, tr.id, pr.id, { ...cruzado, prova: (0, hitl_gates_1.assinaturaDaResposta)(tr.id, pr.id, cruzado, chaves.hermes) });
+                }
+                catch {
+                    recusas++;
+                }
+                // FX5: conta fora da allowlist do canal, com assinatura correta, tambem e recusada.
+                const outraConta = { ...cruzado, conta: 'conta-nao-autorizada', mensagem: 'telegram:-7:conta' };
+                try {
+                    (0, hitl_gates_1.responderGate)(s.dir, tr.id, pr.id, { ...outraConta, prova: (0, hitl_gates_1.assinaturaDaResposta)(tr.id, pr.id, outraConta, chaves.openclaw) });
+                }
+                catch {
+                    recusas++;
+                }
+                const semIngresso = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(s.dir, tr.id)).filter(e => e.tipo === 'human_gate').length;
+                // Oferta ao humano: com credencial e conexoes, os quatro ficam disponiveis.
+                const oferta = (0, hitl_canais_1.ofertaDeCanais)({ env: process.env,
+                    conexoesMcp: ['claude-code', 'codex'] });
+                return { simulado: true, canaisRegistrados: registro.canais, transportes: registro.transportes,
+                    chavesIndependentes: registro.chaves,
+                    aprovados: aprovados.length, canaisDistinguiveis: new Set(lidos).size,
+                    canalPorInferencia: lidos.filter(c => c === null).length,
+                    recusas, humanosSemIngresso: semIngresso,
+                    ofertaDisponivel: oferta.filter(o => o.estado === 'disponivel').length };
+            }
+            finally {
+                nomes.forEach((n, i) => { if (antigos[i] === undefined)
+                    delete process.env[n];
+                else
+                    process.env[n] = antigos[i]; });
+                s.limpar();
+            }
+        } },
+];