@orkastery/cli 0.2.0 → 0.4.1

package/dist/fix.js

@@ -74,6 +74,7 @@ const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const verify_1 = require("./verify");
+const conducao_1 = require("./conducao");
 /** Armazem append-only das correcoes da thread. */
 function caminhoDosFixes(raiz, threadId) {
     return path.join((0, thread_1.dirThread)(raiz, threadId), 'fixes.jsonl');
@@ -186,6 +187,20 @@ function specDoGoFix(thread, rodada, correcoes) {
     linhas.push('- Nao ha pausa humana dentro deste sub-loop; o veredito final e que sobe.');
     return linhas.join('\n');
 }
+/**
+ * I-36 (T5): o GO-FIX e o CHECK-REVERIFY executam na worktree, entao seguram a conducao da thread
+ * do comeco ao fim. O `verificar` de dentro reentra no mesmo processo.
+ */
+function sobConducao(carregado, threadId, operacao, conducao, executar) {
+    return (0, conducao_1.comConducao)(carregado.raiz, threadId, {
+        canal: conducao.canal ?? (0, conducao_1.canalDoProcesso)(),
+        correlacao: conducao.correlacao ?? null,
+        operacao,
+        identidade: conducao.identidade ?? (0, conducao_1.identidadeDoAmbiente)(threadId),
+        prazoMs: (0, conducao_1.prazoDaVerificacao)(carregado.manifesto.verify.timeout_ms ?? 10 * 60 * 1000, 8),
+        esperarMs: conducao.esperarMs,
+    }, executar);
+}
 /**
  * Abre a rodada de GO-FIX a partir de um CHECK reprovado.
  *
@@ -193,6 +208,9 @@ function specDoGoFix(thread, rodada, correcoes) {
  * CHECK nenhum, nem no do proprio agente que acabou de rodar.
  */
 function abrirRodada(carregado, threadId, opcoes = {}) {
+    return sobConducao(carregado, threadId, 'fix.open', opcoes.conducao ?? {}, () => abrirRodadaSobConducao(carregado, threadId, opcoes));
+}
+function abrirRodadaSobConducao(carregado, threadId, opcoes) {
     const { raiz } = carregado;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const resultado = (0, verify_1.verificar)(carregado, threadId, { soClaims: opcoes.soClaims });
@@ -256,6 +274,9 @@ function carimbar(raiz, correcao, aprovada, detalhe) {
  * frouxa do que o metodo manda.
  */
 function reverificar(carregado, threadId, opcoes = {}) {
+    return sobConducao(carregado, threadId, 'fix.reverify', opcoes.conducao ?? {}, () => reverificarSobConducao(carregado, threadId, opcoes));
+}
+function reverificarSobConducao(carregado, threadId, opcoes) {
     const { raiz, manifesto } = carregado;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const rodada = opcoes.rodada ?? ultimaRodada(raiz, threadId);
@@ -360,7 +381,7 @@ function reverificar(carregado, threadId, opcoes = {}) {
             modo: thread.modo,
             detalhe: razao,
             evidencia: `rodada ${rodada} de GO-FIX/CHECK-REVERIFY na thread ${threadId}`,
-            correcao: `ork gate approve ${threadId} evidencias --por <quem>`,
+            correcao: `ork gate request ${threadId}`,
             rodada,
             limite,
             pausaQualquerModo: true,

package/dist/gates.js

@@ -19,23 +19,36 @@ exports.registrarGateBloqueado = registrarGateBloqueado;
 exports.registrarGateLiberado = registrarGateLiberado;
 exports.descreverMotivo = descreverMotivo;
 exports.aprovarGateHumano = aprovarGateHumano;
+exports.aprovacaoHumanaProvada = aprovacaoHumanaProvada;
 exports.aprovacoesHumanas = aprovacoesHumanas;
 const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
 const thread_1 = require("./thread");
+const hitl_ingress_receipt_1 = require("./hitl-ingress-receipt");
+const hitl_local_receipt_1 = require("./hitl-local-receipt");
+const hitl_contract_1 = require("./hitl-contract");
 /** O que cada motivo tipado significa, em uma linha, para a saida do CLI. */
 exports.DESCRICAO_DO_MOTIVO = {
     'artifact.missing': 'artefato exigido pela fase nao existe no disco',
     'claims.failed': 'alegacao verificavel reprovou na reexecucao no HEAD real',
     'claims.unverifiable': 'alegacao sem comando de verificacao declarado',
     'policy.violation': 'policy do manifesto com severidade block foi violada',
+    'runtime.autoconferencia': 'o CHECK foi despachado no mesmo runtime que fez o GO, e a thread exige validacao cruzada',
     'verify.regression': 'comando que passava na baseline falha agora',
     'verify.failed': 'comando de verificacao falhou (sem baseline para separar divida pre-existente)',
+    'verify.timeout': 'comando de verificacao estourou o prazo antes de terminar: nao ha veredito sobre ele',
+    'verify.sem-veredito': 'a rodada nao produziu veredito valido: comando que nao chegou a rodar, ou produto alterado entre o preparo e o fim',
+    'ci.failed': 'CHECK independente ausente, pendente ou reprovado no commit candidato',
     'runtime.unavailable': 'runtime adapter indisponivel para o despacho',
+    'runtime.silencio': 'fase despachada sem heartbeat dentro do limite de liveness',
     'runtime.rate-limited': 'o runtime bateu o limite de uso da assinatura e a fase morreu antes de terminar (bloco B3: entra na fila duravel e e retomada na janela seguinte)',
+    'runtime.quota-exhausted': 'a cota ou os creditos da conta do runtime acabaram (I-33: o perfil sai do rodizio e a fase segue em outro perfil, outro runtime ou na fila)',
+    'runtime.auth-missing': 'a conta do runtime nao esta autenticada (I-33: o perfil nunca recebe despacho ate o login ser refeito pelo proprio CLI)',
     'cost.violation': 'o despacho seria redirecionado para provider pago (violacao de custo: e o unico motivo que NUNCA recebe retry automatico)',
     'tree.blocked': 'a arvore de destino nao esta disponivel para o merge (branch em check-out com alteracao nao commitada, ou worktree que nao pode ser montada)',
     'lease.busy': 'lease ocupado por outra thread',
+    'conducao.em-andamento': 'outra conducao ja executa na worktree da thread (I-36): o pedido foi recusado com quem conduz e as tres acoes (esperar, acompanhar, assumir)',
+    'hitl.formato': 'o pedido HITL saiu fora do formato obrigatorio (pergunta em uma frase, de 2 a 4 alternativas rotuladas com consequencia, exatamente uma recomendada com o porque, corpo em lista)',
     'human.pending': 'gate humano do modo de conducao ainda nao autorizou',
 };
 /**
@@ -73,20 +86,55 @@ function descreverMotivo(motivo, detalhe) {
     return `motivo tipado: ${motivo} (${exports.DESCRICAO_DO_MOTIVO[motivo]})\n  detalhe: ${detalhe}`;
 }
 /**
- * `ork gate approve`: o humano autoriza uma pausa do modo pela linha de comando.
+ * `ork gate approve`, APOSENTADO: aprovacao sem pedido e recusada. A pausa se libera pela
+ * resposta ao `ork gate request`, que chega pelo ingresso humano autenticado.
  *
- * E o que torna a "autorizacao antecipada de push" do `#Ork` verificavel: ela vira um
- * evento no ledger com quem autorizou e quando, em vez de memoria de conversa.
+ * Antes da aposentadoria, era o que tornava verificavel a "autorizacao antecipada de push"
+ * do `#Classic`: ela virava um evento no ledger com quem autorizou e quando, em vez de
+ * memoria de conversa.
  */
-function aprovarGateHumano(raiz, threadId, sobre, por, observacao) {
-    return (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.pausaHumana, {
-        estado: 'aprovado',
-        sobre,
-        autorizadoPor: por,
-        observacao: observacao ?? '',
-    });
+function aprovarGateHumano(_raiz, _threadId, _sobre, _por, _observacao) {
+    throw new Error('aprovação cega aposentada: use ork gate request e responda ao pedido pelo ingresso humano autenticado');
+}
+/**
+ * FX2: a FORMA do evento. Sozinha ela nunca autorizou nada de verdade.
+ *
+ * Esta era a checagem inteira: campos presentes e `recibo` com cara de sha256. Quem
+ * conseguisse escrever uma linha no `ledger.jsonl` fabricava uma aprovacao humana que
+ * `retry` e `ship` aceitavam, porque nenhum dos dois reconferia o MAC do ingresso. A forma
+ * continua valendo como primeiro filtro barato; ela so nao decide mais.
+ */
+function formaDeAprovacao(e) {
+    return e.tipo === ledger_1.TIPOS_DE_EVENTO.pausaHumana && e.estado === 'aprovado' &&
+        // I-41 (T4c): as duas versoes do pedido, por lista fechada. Um `human_gate` copia o contrato
+        // do pedido que respondeu; recusar v2 aqui faria a aprovacao do dono parar de valer para
+        // `retry` e `ship` no dia em que o nucleo passasse a emitir v2. Contrato fora da lista
+        // continua recusado, e a prova do recibo, que e quem de fato autoriza, nao muda.
+        (0, hitl_contract_1.ehContratoDePedido)(e.contrato) && typeof e.pedidoId === 'string' && typeof e.recibo === 'string' &&
+        ((e.origem === 'telegram' || e.origem === 'native') && typeof e.mensagem === 'string' ||
+            e.origem === 'mcp-local' && e.proveniencia === 'ork.mcp-elicitation/v1' && e.source === 'human' &&
+                ['mcp-local:codex', 'mcp-local:claude-code'].includes(String(e.autorizadoPor)) &&
+                typeof e.conexao === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(e.conexao) &&
+                typeof e.solicitacao === 'string' && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(e.solicitacao) &&
+                /^[a-f0-9]{64}$/.test(e.recibo));
+}
+/**
+ * FX2: a PROVA do evento, reconferida no momento em que ela autoriza.
+ *
+ * Cada canal ja sabia revalidar o proprio recibo durável; ninguem chamava essas funcoes no
+ * caminho de `retry` e `ship`. Aqui elas passam a ser chamadas, e o custo e o certo: uma
+ * aprovacao com `recibo` adulterado no ledger deixa de autorizar, mesmo com a forma
+ * perfeita. As duas funcoes ja recusam por si so evento sem arquivo, sem MAC, com bytes
+ * trocados no disco ou com canal trocado no ledger.
+ */
+function aprovacaoHumanaProvada(raiz, threadId, e) {
+    if (!formaDeAprovacao(e))
+        return false;
+    if (e.origem === 'telegram' || e.origem === 'native')
+        return (0, hitl_ingress_receipt_1.validarEvidenciaDoIngresso)(raiz, threadId, e);
+    return (0, hitl_local_receipt_1.validarEvidenciaLocal)(raiz, threadId, e);
 }
 /** Aprovacoes humanas ja registradas no ledger da thread, para os gates consultarem. */
 function aprovacoesHumanas(raiz, threadId) {
-    return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId)).filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.pausaHumana && e.estado === 'aprovado');
+    return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId)).filter((e) => aprovacaoHumanaProvada(raiz, threadId, e));
 }

package/dist/handoff.js

@@ -1,24 +1,4 @@
 "use strict";
-/**
- * Handoff triado entre sessoes, regime `files` (visao unificada, secoes 6.1 e 6.2).
- *
- * Quando o gate de tokens veredicta `new-session`, a sessao que abre NAO recebe copia
- * integral da anterior. Ela recebe um handoff com triagem em 3 niveis:
- *
- *   CRITICO   -> vai INLINE, sempre: estado do mundo, decisoes locked, criterios de
- *                sucesso, claims pendentes, baseline.
- *   IMPORTANTE-> vira PONTEIRO `path#ancora`, com instrucao de recuperacao e o momento
- *                de resolve-lo. Nao entra no prompt: entra o endereco.
- *   RESUMIVEL -> vira resumo curto COM proveniencia: historico de tentativas, logs,
- *                exploracao ja concluida.
- *
- * Proveniencia e obrigatoria em todo item: source, location e sha256 do arquivo de
- * origem. Nada entra no contexto da nova sessao sem dizer de onde veio, e tudo o que
- * ficou de fora esta listado como ponteiro, com onde esta e como recuperar.
- *
- * Sem OrkMind, a recuperacao tardia e leitura dirigida (`ork handoff recall`), nao busca
- * semantica. O campo `memory` declara o regime, entao a sessao seguinte sabe o que pedir.
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -62,6 +42,27 @@ exports.exportarHandoff = exportarHandoff;
 exports.ancoraDeTitulo = ancoraDeTitulo;
 exports.recall = recall;
 exports.textoDoHandoff = textoDoHandoff;
+const write_activation_1 = require("./write-activation");
+/**
+ * Handoff triado entre sessoes, regime `files` (guia: docs/guias/memoria-e-handoff.md).
+ *
+ * Quando o gate de tokens veredicta `new-session`, a sessao que abre NAO recebe copia
+ * integral da anterior. Ela recebe um handoff com triagem em 3 niveis:
+ *
+ *   CRITICO   -> vai INLINE, sempre: estado do mundo, decisoes locked, criterios de
+ *                sucesso, claims pendentes, baseline.
+ *   IMPORTANTE-> vira PONTEIRO `path#ancora`, com instrucao de recuperacao e o momento
+ *                de resolve-lo. Nao entra no prompt: entra o endereco.
+ *   RESUMIVEL -> vira resumo curto COM proveniencia: historico de tentativas, logs,
+ *                exploracao ja concluida.
+ *
+ * Proveniencia e obrigatoria em todo item: source, location e sha256 do arquivo de
+ * origem. Nada entra no contexto da nova sessao sem dizer de onde veio, e tudo o que
+ * ficou de fora esta listado como ponteiro, com onde esta e como recuperar.
+ *
+ * Sem OrkMind, a recuperacao tardia e leitura dirigida (`ork handoff recall`), nao busca
+ * semantica. O campo `memory` declara o regime, entao a sessao seguinte sabe o que pedir.
+ */
 const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -132,6 +133,9 @@ function estadoDoMundo(thread) {
 /** Exporta o handoff triado da thread. Deterministico: mesma entrada, mesmo arquivo. */
 function exportarHandoff(carregado, threadId, opcoes = {}) {
     const { raiz, manifesto } = carregado;
+    if (opcoes.memoria?.ativo && opcoes.memoria.leituraRestrita) {
+        throw Error('memory.query.broad-operation: handoff export exige contexto de manutencao ou regime files');
+    }
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     const proximaFase = opcoes.proximaFase ?? thread.faseAtual;
@@ -215,6 +219,8 @@ function exportarHandoff(carregado, threadId, opcoes = {}) {
     }
     // IMPORTANTE: os prompts ja despachados, com o pedido original do builder.
     for (const s of thread.sessoes) {
+        if (s.origem === 'adocao')
+            continue;
         const caminhoPrompt = path.resolve(raiz, s.promptPath);
         if (!fs.existsSync(caminhoPrompt))
             continue;
@@ -235,8 +241,8 @@ function exportarHandoff(carregado, threadId, opcoes = {}) {
         }
     }
     if (thread.sessoes.length > 0) {
-        addResumo(`${thread.sessoes.length} sessao(oes) despachada(s): ` +
-            thread.sessoes.map((s) => `${s.slug} (${s.fase})`).join(', ') +
+        addResumo(`${thread.sessoes.length} sessao(oes) registrada(s): ` +
+            thread.sessoes.map((s) => `${s.slug} (${s.fase}, ${s.origem === 'adocao' ? 'adotada' : 'despachada'})`).join(', ') +
             '. Os prompts estao nos ponteiros acima; a exploracao ja concluida nao vai inline.', proveniencia(raiz, caminhoThreadJson, 'json:sessoes'));
     }
     // Bloco B6: com o regime `orkmind` valendo, o que a memoria semantica JA guarda deste
@@ -289,7 +295,17 @@ function exportarHandoff(carregado, threadId, opcoes = {}) {
     (0, util_1.gravarJson)(caminhoHistorico, handoff);
     // Publicacao na memoria semantica: o pacote de fase (colecao `handoff`) e as decisoes
     // fechadas (colecao `decision`), que sao o que uma thread futura precisa herdar.
-    if (memoria.ativo) {
+    let escritaAutorizada = true;
+    if (!opcoes.memoria && manifesto.memory.mode === 'orkmind') {
+        try {
+            (0, write_activation_1.exigirAtivacao)(carregado, threadId, 'memory');
+        }
+        catch {
+            escritaAutorizada = false;
+            (0, ledger_1.registrar)(dir, threadId, 'memory_publication_pending', { origem: 'handoff export', motivo: 'write.activation.required', arquivoPreservado: true });
+        }
+    }
+    if (memoria.ativo && escritaAutorizada) {
         const publicado = (0, memoria_1.gravarHandoff)(memoria, manifesto, thread, handoff, relativo(raiz, caminhoHistorico));
         const decisoes = (0, memoria_1.gravarDecisoes)(memoria, manifesto, thread);
         (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.memoriaGravada, {

package/dist/hitl-canais.js

@@ -0,0 +1,333 @@
+"use strict";
+/**
+ * D12: domicilio unico dos canais HITL homologados.
+ *
+ * Um CANAL nao e um transporte. `telegram` e `mcp-local` sao dois transportes, e cada um
+ * serve dois hosts; o canal e o par host + ingresso, porque e ele que o humano escolhe e e
+ * ele que precisa aparecer no recibo. Antes deste registro, uma decisao que entrava pelo
+ * Telegram gravava `origem: 'telegram'` e nada mais: depois, ninguem sabia se ela tinha
+ * vindo do Hermes ou do OpenClaw. O `mcp-local` ja distinguia (`mcp-local:claude-code` e
+ * `mcp-local:codex`); metade dos canais homologados era anonima no proprio recibo.
+ *
+ * Tres regras estruturais moram aqui, e so aqui:
+ *
+ *  1. **Sao quatro canais, e a lista e fechada.** Reduzir a lista e mudanca de contrato, nao
+ *     configuracao: `CANAIS` cobre `Host` inteiro, entao um host novo sem canal nao compila,
+ *     e um canal removido reprova em `conferirRegistro`.
+ *  2. **Canal sem os tres atributos nao entra.** Identidade, correlacao e recibo sao o que
+ *     torna dois canais equivalentes. Um canal que so tenha dois deles nao e um canal mais
+ *     fraco: e um canal que nao pode responder, e `conferirRegistro` diz isso com nome.
+ *  3. **Transcrito nativo entra por adaptador, nunca como texto de tool.** O conteudo que o
+ *     humano escreveu chega assinado pelo evento nativo do host (Telegram) ou pelo
+ *     `elicitInput` da propria conexao MCP. Texto que um agente cole num argumento de
+ *     ferramenta e autoaprovacao com outro nome, e `recusarIngressoNaoHomologado` recusa.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORDEM_DOS_CANAIS = exports.CANAIS = exports.VARIAVEL_DA_CONTA = exports.VARIAVEL_DA_CHAVE = exports.VARIAVEL_DA_CHAVE_V1 = exports.CONTRATO_CANAIS = void 0;
+exports.selecaoDeCanal = selecaoDeCanal;
+exports.reservaDoPedido = reservaDoPedido;
+exports.conferirCanalSelecionado = conferirCanalSelecionado;
+exports.variavelDaChaveDoCanal = variavelDaChaveDoCanal;
+exports.canaisHomologados = canaisHomologados;
+exports.parseCanal = parseCanal;
+exports.definicaoDoCanal = definicaoDoCanal;
+exports.canaisDoTransporte = canaisDoTransporte;
+exports.transporteDoCanal = transporteDoCanal;
+exports.equivalenciaDoCanal = equivalenciaDoCanal;
+exports.recusarIngressoNaoHomologado = recusarIngressoNaoHomologado;
+exports.conferirRegistro = conferirRegistro;
+exports.ofertaNativa = ofertaNativa;
+exports.ofertaDeCanais = ofertaDeCanais;
+exports.canalDaResposta = canalDaResposta;
+const node_crypto_1 = require("node:crypto");
+const hosts_1 = require("./hosts");
+const hitl_native_1 = require("./hitl-native");
+function selecaoDeCanal(eventos, pedidoId) {
+    const last = eventos.filter(e => ['hitl_channel_selected', 'hitl_channel_released'].includes(e.tipo) && e.pedidoId === pedidoId).at(-1);
+    return last?.tipo === 'hitl_channel_selected' ? last : undefined;
+}
+/**
+ * Leitura para a oferta native: o que impede um ingresso native novo deste pedido agora.
+ * Ingresso native nunca seleciona canal, então toda seleção vigente é reserva de outro canal
+ * (MCP), e `conferirCanalSelecionado` recusaria a resposta. Não reserva, não libera e não
+ * prova abandono: devolve motivo curto ou vazio.
+ */
+function reservaDoPedido(eventos, pedidoId) {
+    if (eventos.some(e => ['human_gate', 'session_answered'].includes(e.tipo) && e.pedidoId === pedidoId))
+        return 'hitl.channel.answered';
+    if (eventos.some(e => e.tipo === 'session_answer_sending' && e.pedidoId === pedidoId))
+        return 'hitl.channel.delivery-uncertain';
+    return selecaoDeCanal(eventos, pedidoId) ? 'hitl.channel.in-use' : '';
+}
+/** Consulta de oferta não autoriza efeito. A seleção vigente amarra o ingresso real. */
+function conferirCanalSelecionado(eventos, pedidoId, canal, transporte, connectionId, requestId) {
+    if (!eventos.some(e => e.tipo === 'hitl_channel_selected' && e.pedidoId === pedidoId))
+        return; // legado
+    const s = selecaoDeCanal(eventos, pedidoId);
+    // Release devolve o pedido ao ingresso autenticado. Um callback MCP antigo
+    // ainda exige sua seleção exata; envio incerto nunca permite trocar de canal.
+    if (!s && transporte !== 'mcp-local' && !eventos.some(e => e.tipo === 'session_answer_sending' && e.pedidoId === pedidoId))
+        return;
+    if (!s || s.canal !== canal || s.transporte !== transporte || s.connectionId !== connectionId || s.requestId !== requestId)
+        throw Error('hitl.channel.selection-mismatch');
+}
+exports.CONTRATO_CANAIS = 'ork.hitl-canais/v1';
+/**
+ * FX1: a chave de ingresso e do CANAL, nao do transporte.
+ *
+ * Hermes e OpenClaw compartilhavam `ORK_HITL_INGRESS_KEY`. Poe-los no mesmo segredo e o
+ * mesmo defeito que D12 conserta no recibo, so que em criptografia: quem vaza a chave de um
+ * host assina envelopes do outro, e nenhuma conferencia posterior percebe, porque a
+ * assinatura confere. Cada canal de telegram passa a ter a sua variavel, e a global fica
+ * EXCLUSIVAMENTE para o envelope v1, que nao declara canal e nao pode ganhar um por
+ * inferencia. Um v1 continua valendo byte a byte; o risco legado dele esta documentado.
+ */
+exports.VARIAVEL_DA_CHAVE_V1 = 'ORK_HITL_INGRESS_KEY';
+/** `null` no canal MCP local: ali a prova vem da conexao, nunca de chave de ambiente. */
+exports.VARIAVEL_DA_CHAVE = {
+    openclaw: 'ORK_HITL_INGRESS_KEY_OPENCLAW',
+    hermes: 'ORK_HITL_INGRESS_KEY_HERMES',
+    'claude-code': null,
+    codex: null,
+};
+/**
+ * FX5: a CONTA homologada do canal, quando ele tem uma.
+ *
+ * O OpenClaw ja conferia `accountId` contra `ORK_HITL_OPENCLAW_ACCOUNT`, mas so no
+ * adaptador, de forma transiente: nada disso entrava no corpo assinado nem no recibo
+ * duravel, entao o recibo provava transporte telegram generico, nunca a conta autorizada.
+ * Quem lesse o recibo depois nao tinha como reconferir de qual conta a decisao entrou.
+ * Hermes nao tem conta propria (a allowlist dele e de usuario e chat), e por isso declara
+ * `null`: um envelope que traga conta num canal sem conta e recusado, e nao ignorado.
+ */
+exports.VARIAVEL_DA_CONTA = {
+    openclaw: 'ORK_HITL_OPENCLAW_ACCOUNT',
+    hermes: null,
+    'claude-code': null,
+    codex: null,
+};
+/** Nome da variavel que autentica este canal. `null` (v1 legado) usa a chave global. */
+function variavelDaChaveDoCanal(canal) {
+    if (canal === null)
+        return exports.VARIAVEL_DA_CHAVE_V1;
+    const nome = exports.VARIAVEL_DA_CHAVE[canal];
+    if (!nome)
+        throw new Error(`hitl.canal.sem-chave-de-ingresso: ${canal} autentica pela conexao`);
+    return nome;
+}
+/**
+ * Os quatro canais. `Record<Canal, ...>` e o que impede a lista de encolher em silencio:
+ * apagar uma entrada aqui e erro de tipo, nao um canal a menos descoberto em producao.
+ */
+exports.CANAIS = {
+    openclaw: {
+        canal: 'openclaw',
+        transporte: 'telegram',
+        ingresso: 'evento-nativo-openclaw',
+        adaptador: 'adapters/openclaw/src/hitl-ingress.ts',
+        identidade: 'telegram:<userId> da allowlist, com canal=openclaw e conta autorizada assinados no corpo do envelope',
+        correlacao: 'pedidoId e mensagem telegram:<chatId>:<messageId>, ambos dentro do HMAC',
+        recibo: 'ingresso duravel em .orkastery/threads/<t>/hitl-ingress/<sha>.json, com conta e canal dentro do MAC e sha256 no ledger',
+        exigencias: ['ORK_HITL_ROOT', 'ORK_HITL_TELEGRAM_BOT_ID', 'ORK_HITL_INGRESS_KEY_OPENCLAW',
+            'ORK_HITL_OPENCLAW_ACCOUNT', 'ORK_HITL_TELEGRAM_USERS', 'ORK_HITL_TELEGRAM_CHATS'],
+    },
+    hermes: {
+        canal: 'hermes',
+        transporte: 'telegram',
+        ingresso: 'evento-nativo-hermes',
+        adaptador: 'adapters/hermes/hitl-ingress/__init__.py',
+        identidade: 'telegram:<userId> da allowlist, com canal=hermes assinado no corpo do envelope',
+        correlacao: 'pedidoId e mensagem telegram:<chatId>:<messageId>, ambos dentro do HMAC',
+        recibo: 'ingresso duravel em .orkastery/threads/<t>/hitl-ingress/<sha>.json, com MAC proprio e sha256 no ledger',
+        exigencias: ['ORK_HITL_ROOT', 'ORK_HITL_TELEGRAM_BOT_ID', 'ORK_HITL_INGRESS_KEY_HERMES',
+            'ORK_HITL_TELEGRAM_USERS', 'ORK_HITL_TELEGRAM_CHATS'],
+    },
+    'claude-code': {
+        canal: 'claude-code',
+        transporte: 'mcp-local',
+        ingresso: 'elicitation-mcp',
+        adaptador: 'core/src/mcp-server.ts',
+        identidade: 'mcp-local:claude-code, com o connectionId da conexao que elicitou',
+        correlacao: 'requestId da elicitation, contexto da thread e pedidoSha256 conferidos sob lock',
+        recibo: 'evidencia local em .orkastery/threads/<t>/hitl-ingress-local/<sha>.json, com sha256 no ledger',
+        exigencias: [],
+    },
+    codex: {
+        canal: 'codex',
+        transporte: 'mcp-local',
+        ingresso: 'elicitation-mcp',
+        adaptador: 'core/src/mcp-server.ts',
+        identidade: 'mcp-local:codex, com o connectionId da conexao que elicitou',
+        correlacao: 'requestId da elicitation, contexto da thread e pedidoSha256 conferidos sob lock',
+        recibo: 'evidencia local em .orkastery/threads/<t>/hitl-ingress-local/<sha>.json, com sha256 no ledger',
+        exigencias: [],
+    },
+};
+/** A ordem de apresentacao e a mesma dos hosts: o humano ve sempre a mesma fila. */
+exports.ORDEM_DOS_CANAIS = hosts_1.ORDEM_DOS_HOSTS;
+function canaisHomologados() {
+    return exports.ORDEM_DOS_CANAIS.map((c) => exports.CANAIS[c]);
+}
+/** Reconhece o canal com os mesmos apelidos que o builder ja digita para o host. */
+function parseCanal(bruto) {
+    return (0, hosts_1.parseHost)(bruto);
+}
+function definicaoDoCanal(bruto) {
+    const canal = parseCanal(bruto);
+    if (!canal)
+        throw new Error('hitl.canal.desconhecido');
+    return exports.CANAIS[canal];
+}
+/** Os canais de um transporte. Preserva a ordem canonica. */
+function canaisDoTransporte(transporte) {
+    return exports.ORDEM_DOS_CANAIS.filter((c) => exports.CANAIS[c].transporte === transporte);
+}
+function transporteDoCanal(bruto) {
+    return definicaoDoCanal(bruto).transporte;
+}
+/**
+ * Os tres atributos que tornam dois canais equivalentes. Vazio em qualquer um deles nao e
+ * um canal pior: e um canal que nao responde, e `conferirRegistro` o nomeia.
+ */
+function equivalenciaDoCanal(bruto) {
+    const d = definicaoDoCanal(bruto);
+    return { identidade: d.identidade, correlacao: d.correlacao, recibo: d.recibo };
+}
+/**
+ * Recusa qualquer ingresso que nao seja um dos adaptadores homologados. O nome do erro e
+ * proposital: quem le o ledger precisa distinguir "canal errado" de "texto de agente".
+ */
+function recusarIngressoNaoHomologado(ingresso) {
+    const homologados = new Set(canaisHomologados().map((c) => c.ingresso));
+    if (typeof ingresso !== 'string' || !homologados.has(ingresso)) {
+        throw new Error('hitl.canal.transcrito-de-tool: ingresso nao homologado nao entrega resposta humana');
+    }
+    return ingresso;
+}
+/** Invariantes do registro. O teste chama isto; o produto tambem, no canario. */
+function conferirRegistro() {
+    const canais = canaisHomologados();
+    if (canais.length !== hosts_1.ORDEM_DOS_HOSTS.length || canais.length !== 4) {
+        throw new Error('hitl.canal.registro-incompleto: os quatro canais homologados sao obrigatorios');
+    }
+    const vistos = new Set(), chaves = new Set();
+    for (const d of canais) {
+        if (d.canal !== exports.ORDEM_DOS_CANAIS[canais.indexOf(d)])
+            throw new Error('hitl.canal.ordem-divergente');
+        for (const [nome, valor] of Object.entries(equivalenciaDoCanal(d.canal))) {
+            if (!valor.trim())
+                throw new Error(`hitl.canal.sem-${nome}: ${d.canal}`);
+        }
+        if (!d.adaptador.trim())
+            throw new Error(`hitl.canal.sem-adaptador: ${d.canal}`);
+        recusarIngressoNaoHomologado(d.ingresso);
+        // Identidade repetida entre canais e o defeito que D12 conserta: dois canais
+        // indistinguiveis no recibo sao, na pratica, um canal so com dois nomes.
+        if (vistos.has(d.identidade))
+            throw new Error(`hitl.canal.identidade-ambigua: ${d.canal}`);
+        vistos.add(d.identidade);
+        // FX1: chave compartilhada e identidade ambigua em criptografia. Dois canais que
+        // assinam com o mesmo segredo podem assinar um pelo outro, e a conferencia aprova.
+        const chave = exports.VARIAVEL_DA_CHAVE[d.canal];
+        if (chave !== null) {
+            if (chave === exports.VARIAVEL_DA_CHAVE_V1)
+                throw new Error(`hitl.canal.chave-global: ${d.canal}`);
+            if (chaves.has(chave))
+                throw new Error(`hitl.canal.chave-ambigua: ${d.canal}`);
+            chaves.add(chave);
+            if (!d.exigencias.includes(chave))
+                throw new Error(`hitl.canal.chave-fora-das-exigencias: ${d.canal}`);
+        }
+        const conta = exports.VARIAVEL_DA_CONTA[d.canal];
+        if (conta !== null && !d.exigencias.includes(conta))
+            throw new Error(`hitl.canal.conta-fora-das-exigencias: ${d.canal}`);
+    }
+    return { contrato: exports.CONTRATO_CANAIS, canais: canais.length,
+        transportes: new Set(canais.map((c) => c.transporte)).size, chaves: chaves.size };
+}
+/** Oferta adicional; disponibilidade exige vínculo privado e callback homologado pelo host. */
+function ofertaNativa(canal, callbackProved, env = process.env) {
+    try {
+        if (!callbackProved)
+            throw Error('hitl.native.capability-unavailable');
+        (0, hitl_native_1.nativeBinding)(canal, env);
+        (0, hitl_native_1.nativeKey)(canal, env);
+        return { canal, transporte: 'native', estado: 'disponivel', motivo: '' };
+    }
+    catch {
+        return { canal, transporte: 'native', estado: 'indisponivel', motivo: 'hitl.native.capability-unavailable' };
+    }
+}
+/**
+ * A oferta que o humano ve. Nao autoriza nada e nao abre pedido: diz, para um pedido ja
+ * aberto, por quais canais da para responder e por que os outros nao servem agora. Sem
+ * oferta nao existe escolha de canal, e sem escolha D12 seria so uma tabela bonita.
+ */
+function ofertaDeCanais(ambiente = {}) {
+    const env = ambiente.env ?? {};
+    const conexoes = new Set(ambiente.conexoesMcp ?? []);
+    const chaveHermes = env.ORK_HITL_INGRESS_KEY_HERMES ?? '';
+    const chaveOpenClaw = env.ORK_HITL_INGRESS_KEY_OPENCLAW ?? '';
+    const chavesTelegramIguais = chaveHermes.length > 0 && chaveOpenClaw.length > 0 &&
+        (0, node_crypto_1.createHash)('sha256').update(chaveHermes).digest('hex') ===
+            (0, node_crypto_1.createHash)('sha256').update(chaveOpenClaw).digest('hex');
+    return canaisHomologados().map((d) => {
+        const faltando = d.exigencias.filter((nome) => !(env[nome] ?? '').trim());
+        if (faltando.length) {
+            return { canal: d.canal, transporte: d.transporte, estado: 'indisponivel',
+                motivo: `hitl.credencial: ausente ${faltando.join(', ')}` };
+        }
+        if (d.transporte === 'telegram') {
+            const raiz = env.ORK_HITL_ROOT ?? '';
+            const bot = env.ORK_HITL_TELEGRAM_BOT_ID ?? '';
+            const usuarios = (env.ORK_HITL_TELEGRAM_USERS ?? '').split(',').map(v => v.trim()).filter(Boolean);
+            const chats = (env.ORK_HITL_TELEGRAM_CHATS ?? '').split(',').map(v => v.trim()).filter(Boolean);
+            const nomeChave = exports.VARIAVEL_DA_CHAVE[d.canal];
+            const chave = nomeChave ? env[nomeChave] ?? '' : '';
+            const invalidas = [
+                !pathAbsoluto(raiz) ? 'ORK_HITL_ROOT deve ser absoluto' : '',
+                !/^\d+$/.test(bot) ? 'ORK_HITL_TELEGRAM_BOT_ID deve ser numerico' : '',
+                usuarios.length === 0 || usuarios.some(v => !/^\d+$/.test(v))
+                    ? 'ORK_HITL_TELEGRAM_USERS deve ser allowlist numerica' : '',
+                chats.length === 0 || chats.some(v => !/^-?\d+$/.test(v))
+                    ? 'ORK_HITL_TELEGRAM_CHATS deve ser allowlist numerica' : '',
+                Buffer.byteLength(chave) < 32 ? `${nomeChave} deve ter ao menos 32 bytes` : '',
+                chavesTelegramIguais ? 'chaves de Hermes e OpenClaw devem ser distintas' : '',
+            ].filter(Boolean);
+            if (invalidas.length) {
+                return { canal: d.canal, transporte: d.transporte, estado: 'indisponivel',
+                    motivo: `hitl.credencial: invalida (${invalidas.join('; ')})` };
+            }
+        }
+        if (d.transporte === 'mcp-local' && !conexoes.has(d.canal)) {
+            return { canal: d.canal, transporte: d.transporte, estado: 'indisponivel',
+                motivo: 'hitl.canal.sem-conexao: nenhuma sessao MCP deste host esta ligada a esta thread' };
+        }
+        return { canal: d.canal, transporte: d.transporte, estado: 'disponivel', motivo: '' };
+    });
+}
+/** Equivalente sintatico de `path.isAbsolute`, sem tocar no filesystem nem no cwd. */
+function pathAbsoluto(valor) {
+    return valor.startsWith('/') || /^[A-Za-z]:[\\/]/.test(valor);
+}
+/**
+ * Le o canal de um `human_gate` ja gravado. Recibo anterior a D12 nao ganha canal por
+ * inferencia: `telegram` sem canal assinado poderia ser Hermes ou OpenClaw, e chutar qual
+ * foi e pior do que admitir que o recibo daquela epoca nao guardava a informacao.
+ */
+function canalDaResposta(evento) {
+    const declarado = parseCanal(typeof evento.canal === 'string' ? evento.canal : null);
+    if (declarado)
+        return { canal: declarado, equivalencia: 'completa', motivo: '' };
+    const origem = typeof evento.origem === 'string' ? evento.origem : '';
+    if (origem === 'telegram') {
+        return { canal: null, equivalencia: 'legado',
+            motivo: 'recibo ork.hitl-answer/v1: transporte telegram sem canal assinado' };
+    }
+    const porMcp = /^mcp-local:(.+)$/.exec(String(evento.autorizadoPor ?? ''));
+    const canal = porMcp ? parseCanal(porMcp[1]) : null;
+    if (canal && exports.CANAIS[canal].transporte === 'mcp-local') {
+        return { canal, equivalencia: 'completa', motivo: '' };
+    }
+    return { canal: null, equivalencia: 'legado', motivo: 'recibo sem canal homologado' };
+}