@orkastery/cli 0.2.0 → 0.4.1

package/dist/hitl-lote.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TETO_DA_MENSAGEM = exports.CONSEQUENCIA_DA_ACAO = exports.LETRAS = exports.TETO_DE_PERGUNTAS_POR_LOTE = exports.CONTRATO_LOTE = void 0;
+exports.alternativaRecomendada = alternativaRecomendada;
+exports.perguntaDoPedido = perguntaDoPedido;
+exports.montarLote = montarLote;
+exports.guardadasDepoisDoLote = guardadasDepoisDoLote;
+exports.linhaDasRecusas = linhaDasRecusas;
+exports.textoDoLote = textoDoLote;
+/**
+ * I-41 (D4 e D16), CAMADA 2: o lote que so sai depois do sim.
+ *
+ * O dono desenhou assim: "so depois do SIM. Ai sim chegam as perguntas, topificadas, DE 5 EM 5,
+ * cada uma com alternativas a, b, c, d e UMA recomendada com o porque em uma linha, e a
+ * consequencia de cada alternativa em uma linha."
+ *
+ * O que muda em relacao ao lote que o PLAN ja previa (D4) e uma coisa so: ele nao sai sozinho.
+ * `loteLiberado` do consentimento e a porta.
+ *
+ * A REGRA QUE FECHA O BURACO DE E5. Um pedido so entra no lote quando da para dizer, sem
+ * adivinhar, qual alternativa e a recomendada. Hoje o produto emite "Confira artefatos, claims e
+ * riscos antes de responder.", que nao aponta alternativa nenhuma; pedido assim e RECUSADO com
+ * motivo `hitl.formato` e contado a parte, em vez de sair com uma recomendada escolhida no chute
+ * pelo agente. Recusa de formato e defeito do EMISSOR, corrigivel por spec dirigida, e nunca
+ * escalacao para o dono: escalar formato para o humano seria pedir que ele revise a sintaxe do
+ * robo. O item continua na fila e continua contado no resumo; ele so nao vira pergunta.
+ *
+ * A consequencia de cada alternativa NAO e inventada: ela sai da acao que a alternativa executa,
+ * por mapa congelado. Acao e o que de fato acontece; texto livre seria opiniao.
+ */
+const hitl_contract_1 = require("./hitl-contract");
+const hitl_1 = require("./hitl");
+exports.CONTRATO_LOTE = 'ork.hitl-lote/v1';
+/** De cinco em cinco, como o dono pediu. As que sobram continuam guardadas, nao somem. */
+exports.TETO_DE_PERGUNTAS_POR_LOTE = 5;
+/** De 2 a 4 alternativas, rotuladas em sequencia. Cinco nao cabem numa escolha rapida. */
+exports.LETRAS = ['a', 'b', 'c', 'd'];
+/**
+ * O que acontece ao escolher, por acao. Mapa TOTAL sobre as acoes do pedido: acao nova quebra o
+ * build aqui, que e o comportamento desejado. Uma alternativa sem consequencia dita e uma
+ * escolha feita no escuro.
+ */
+exports.CONSEQUENCIA_DA_ACAO = Object.freeze({
+    aprovar: 'a fase segue e o bloco avança',
+    recusar: 'a fase volta para revisão',
+    responder: 'a resposta é encaminhada à sessão que perguntou',
+    esperar: 'nada muda; o item continua na fila',
+});
+/** Teto de uma linha. Consequência que vira parágrafo deixa de ser leitura rápida. */
+const LIMITE_DE_LINHA = 140;
+const linha = (texto) => (0, hitl_1.redigirSegredos)(String(texto)).replace(/\s+/g, ' ').trim().slice(0, LIMITE_DE_LINHA);
+/** As alternativas de um pedido v2, quando ele ja traz as suas prontas. */
+function alternativasDeclaradas(pedido) {
+    const brutas = pedido.alternativas;
+    if (!Array.isArray(brutas) || brutas.length < 2 || brutas.length > exports.LETRAS.length)
+        return undefined;
+    const alternativas = [];
+    let recomendadas = 0;
+    for (const [i, bruta] of brutas.entries()) {
+        const o = bruta;
+        if (typeof o.texto !== 'string' || typeof o.consequencia !== 'string')
+            return undefined;
+        const recomendada = o.recomendada === true;
+        if (recomendada) {
+            if (typeof o.porque !== 'string' || !o.porque.trim())
+                return undefined;
+            recomendadas++;
+        }
+        alternativas.push({
+            letra: exports.LETRAS[i], texto: linha(o.texto), consequencia: linha(o.consequencia),
+            ...(recomendada ? { recomendada: { porque: linha(String(o.porque)) } } : {}),
+        });
+    }
+    return recomendadas === 1 ? alternativas : undefined;
+}
+/**
+ * Qual alternativa a recomendacao do pedido NOMEIA, ou -1 quando ela nao nomeia nenhuma.
+ *
+ * A regra e literal de proposito: a recomendacao precisa conter o texto de uma das opcoes. Uma
+ * recomendacao que cita duas e ambigua e tambem nao serve. Nada aqui interpreta intencao.
+ */
+function alternativaRecomendada(pedido) {
+    const recomendacao = (0, hitl_contract_1.recomendacaoDoPedido)(pedido).toLowerCase();
+    const citadas = (0, hitl_contract_1.escolhasDoPedido)(pedido)
+        .map((o, i) => ({ i, achou: !!o.texto.trim() && recomendacao.includes(o.texto.trim().toLowerCase()) }))
+        .filter(o => o.achou);
+    return citadas.length === 1 ? citadas[0].i : -1;
+}
+/**
+ * Traduz um pedido em pergunta do lote, ou diz por que ele nao virou uma.
+ *
+ * Duas fontes de alternativa, nesta ordem: as declaradas pelo proprio pedido (`ork.hitl/v2`) e,
+ * na falta delas, as opcoes de um pedido `ork.hitl/v1` com a consequencia vinda do mapa
+ * congelado e a recomendada sendo a que a recomendacao do pedido NOMEIA.
+ */
+function perguntaDoPedido(pedido, numero) {
+    const recusa = (detalhe) => ({ pedidoId: pedido.id, thread: pedido.thread ?? null, motivo: 'hitl.formato', detalhe });
+    // I-41 (T4c): um fato consumado nao e pergunta. Ele nao tem alvo, nao tem escolha e nao pede
+    // nada; deixar `textoDoPedido` devolver o que foi decidido faria a camada 2 perguntar sobre
+    // algo que ja aconteceu. A recusa e por ausencia de alvo, que e o criterio estrutural.
+    if (!(0, hitl_contract_1.alvoDoPedido)(pedido))
+        return recusa('decisão informada não é pergunta');
+    const pergunta = linha((0, hitl_contract_1.textoDoPedido)(pedido));
+    if (!pergunta)
+        return recusa('pergunta vazia');
+    const declaradas = alternativasDeclaradas(pedido);
+    if (declaradas) {
+        return { numero, thread: pedido.thread ?? null, fase: pedido.fase ?? null, pergunta, alternativas: declaradas, pedidoId: pedido.id };
+    }
+    // I-41 (T4c): o parser da recomendacao e exclusivo do v1, e a porta se fecha aqui.
+    //
+    // Um v2 com duas recomendadas, ou sem consequencia, nao produz alternativas declaradas. Sem
+    // esta linha ele cairia no caminho de baixo, onde `recomendacaoDoPedido` devolve o texto da
+    // PRIMEIRA recomendada; esse texto cita o rotulo de uma opcao, o parser acha exatamente uma e
+    // o pedido malformado entraria no lote com uma recomendada escolhida por acidente. E
+    // exatamente o chute que a camada 2 existe para recusar, so que vindo por dentro.
+    if ((0, hitl_contract_1.ehV2)(pedido))
+        return recusa('alternativas declaradas inválidas: v2 não cai no parser do v1');
+    const opcoes = (0, hitl_contract_1.escolhasDoPedido)(pedido);
+    if (opcoes.length < 2)
+        return recusa('menos de 2 alternativas');
+    if (opcoes.length > exports.LETRAS.length)
+        return recusa(`mais de ${exports.LETRAS.length} alternativas`);
+    const recomendada = alternativaRecomendada(pedido);
+    if (recomendada < 0)
+        return recusa('a recomendação não nomeia exatamente uma alternativa');
+    return {
+        numero, thread: pedido.thread ?? null, fase: pedido.fase ?? null, pergunta, pedidoId: pedido.id,
+        alternativas: opcoes.map((o, i) => ({
+            letra: exports.LETRAS[i], texto: linha(o.texto), consequencia: exports.CONSEQUENCIA_DA_ACAO[o.acao],
+            ...(i === recomendada ? { recomendada: { porque: linha((0, hitl_contract_1.recomendacaoDoPedido)(pedido)) } } : {}),
+        })),
+    };
+}
+/**
+ * O lote de ate cinco perguntas. O que sobra continua guardado e vai no proximo, e o que foi
+ * recusado por formato e contado a parte, para que ninguem confunda "nao perguntei" com
+ * "perguntei e nao houve resposta".
+ */
+function montarLote(pedidos, opcoes = {}) {
+    const teto = opcoes.teto ?? exports.TETO_DE_PERGUNTAS_POR_LOTE;
+    // O numero continua de um lote para o outro enquanto o anterior ainda pode ser respondido:
+    // "1a" nunca pode querer dizer duas perguntas diferentes ao mesmo tempo.
+    const inicio = opcoes.numeroInicial ?? 1;
+    const perguntas = [], recusadas = [];
+    const vistos = new Set();
+    let elegiveis = 0, abertas = 0;
+    for (const pedido of pedidos) {
+        // O mesmo pedido chega por dois itens do pulse quando a sessao e a fase param pelo mesmo gate.
+        // Perguntar duas vezes a mesma coisa, com dois numeros, era um jeito de o dono responder errado.
+        if (vistos.has(pedido.id))
+            continue;
+        vistos.add(pedido.id);
+        // A3: `tipoDeResposta` e lido. Aberta nao se responde por letra e nao sai no meio das
+        // objetivas: fica fora deste lote e e contada, para ninguem confundir fora com perdida.
+        if ((0, hitl_contract_1.ehV2)(pedido) && pedido.classe === 'pergunta' && pedido.tipoDeResposta === 'aberta') {
+            abertas++;
+            continue;
+        }
+        const resultado = perguntaDoPedido(pedido, inicio + perguntas.length);
+        if ('motivo' in resultado) {
+            recusadas.push(resultado);
+            continue;
+        }
+        elegiveis++;
+        if (perguntas.length < teto)
+            perguntas.push(resultado);
+    }
+    return { contrato: exports.CONTRATO_LOTE, perguntas, restantes: elegiveis - perguntas.length, recusadas, abertas };
+}
+/** Quantas perguntas continuam guardadas depois deste lote, para o resumo citar. */
+function guardadasDepoisDoLote(lote) {
+    return lote.restantes;
+}
+function corpoDaPergunta(p, marca) {
+    const cabecalho = [p.thread, p.fase].filter(Boolean).join(' · ');
+    return [
+        `${p.numero}. ${cabecalho || 'sem thread'}`,
+        `   ${p.pergunta}`,
+        ...p.alternativas.flatMap(a => [
+            `   ${a.letra}) ${a.texto}${a.recomendada ? `  ${marca}recomendada` : ''}`,
+            `      → ${a.consequencia}`,
+            ...(a.recomendada ? [`      porquê: ${a.recomendada.porque}`] : []),
+        ]),
+    ];
+}
+/** A5: a frase dos pedidos que nao viraram pergunta, com a concordancia certa para o dono ler. */
+function linhaDasRecusas(n) {
+    return n === 1
+        ? '1 pedido não virou pergunta por defeito de quem escreveu; o conserto é nosso, não seu.'
+        : `${n} pedidos não viraram pergunta por defeito de quem escreveu; o conserto é nosso, não seu.`;
+}
+/** Teto de uma mensagem de Telegram, com folga: o mesmo que a mensagem por item ja usava. */
+exports.TETO_DA_MENSAGEM = 3900;
+/**
+ * O texto do lote no canal. Mesma regra da camada 1: quem monta e o nucleo, e o humano nunca
+ * recebe JSON nem identificador longo. Ele responde pelo numero da pergunta mais a letra.
+ */
+function textoDoLote(lote, opcoes) {
+    if (lote.contrato !== exports.CONTRATO_LOTE)
+        throw new Error('lote HITL: contrato inválido');
+    const telegram = opcoes.canal === 'telegram';
+    const n = lote.perguntas.length;
+    const exemplo = lote.perguntas.map(p => `${p.numero}${p.alternativas[0].letra}`).join(' ');
+    const faltam = opcoes.proximo?.faltam ?? lote.restantes;
+    return [
+        `${telegram ? '📋 ' : ''}Orkastery, ${n === 1 ? '1 pergunta' : `${n} perguntas`}`,
+        '',
+        ...lote.perguntas.flatMap((p, i) => [...corpoDaPergunta(p, telegram ? '✅ ' : '← '), ...(i < n - 1 ? [''] : [])]),
+        '',
+        ...(n ? [`Responda com o número e a letra, por exemplo: ${exemplo}.`] : ['Nenhuma pergunta em formato respondível agora.']),
+        ...(opcoes.proximo && faltam
+            ? [`Falta${faltam === 1 ? '' : 'm'} ${faltam}. Para receber as próximas, responda ${opcoes.proximo.codigo} a.`]
+            : faltam ? [`Sobra${faltam === 1 ? '' : 'm'} ${faltam} para o próximo lote.`] : []),
+        ...(lote.abertas
+            ? [`${lote.abertas === 1 ? '1 pergunta aberta fica' : `${lote.abertas} perguntas abertas ficam`} para depois das objetivas, uma por vez.`]
+            : []),
+        ...(opcoes.naoEsperam
+            ? [`${opcoes.naoEsperam === 1 ? '1 pergunta do resumo já não esperava' : `${opcoes.naoEsperam} perguntas do resumo já não esperavam`} você quando fui buscar.`]
+            : []),
+        ...(lote.recusadas.length ? [linhaDasRecusas(lote.recusadas.length)] : []),
+    ].join('\n').slice(0, exports.TETO_DA_MENSAGEM);
+}

package/dist/hitl-native-offer.js

@@ -0,0 +1,97 @@
+"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.nativeOfferSignature = nativeOfferSignature;
+exports.provenNativeOffer = provenNativeOffer;
+exports.readNativeOfferStdin = readNativeOfferStdin;
+/** Prova efêmera de callback para apresentação. Não autoriza resposta nem gate. */
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const zod_1 = require("zod");
+const hitl_contract_1 = require("./hitl-contract");
+const hitl_native_1 = require("./hitl-native");
+const offerSchema = zod_1.z.object({
+    native: hitl_native_1.nativeBindingSchema.extend({ messageId: zod_1.z.string().min(1).max(200).regex(/^[^\u0000-\u001f]+$/) }).strict(),
+    recebidoEm: zod_1.z.string().datetime(), prova: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+}).strict();
+function nativeOfferSignature(thread, pedido, offer, key) {
+    const n = offer.native;
+    return (0, node_crypto_1.createHmac)('sha256', key).update(JSON.stringify(['ork.hitl-native-offer/v1', thread, pedido,
+        n.host, n.installationId, n.connectionId, n.sessionId, n.accountId, n.channelId,
+        n.conversationId, n.personId, n.messageId, offer.recebidoEm])).digest('hex');
+}
+/**
+ * I-41 (T4b): as duas versoes entram, e um fato consumado NUNCA sai provado.
+ *
+ * A prova serve para oferecer um caminho de resposta. `decidido` nao tem prazo e nao tem
+ * resposta: sem prazo nao existe a janela que esta funcao confere, e deixar `Date.parse('')`
+ * virar `NaN` faria a comparacao ser falsa e a oferta seguir adiante. Prazo ausente barra aqui,
+ * explicitamente, para que nenhum canal apareca `disponivel` para quem nao tem o que responder.
+ */
+function provenNativeOffer(pedido, value) {
+    try {
+        const prazo = (0, hitl_contract_1.prazoDoPedido)(pedido);
+        if (prazo === undefined)
+            return undefined;
+        const offer = offerSchema.parse(value), n = offer.native, binding = (0, hitl_native_1.nativeBinding)(n.host);
+        const age = Date.now() - Date.parse(offer.recebidoEm);
+        if (age < 0 || age > 60000 || Date.now() >= Date.parse(prazo) ||
+            Object.entries(binding).some(([k, v]) => n[k] !== v))
+            return undefined;
+        const expected = nativeOfferSignature(pedido.thread, pedido.id, offer, (0, hitl_native_1.nativeKey)(n.host));
+        return (0, node_crypto_1.timingSafeEqual)(Buffer.from(expected, 'hex'), Buffer.from(offer.prova, 'hex')) ? n.host : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readNativeOfferStdin() {
+    const buffer = Buffer.alloc(8193);
+    let total = 0;
+    for (;;) {
+        const count = fs.readSync(0, buffer, total, buffer.length - total, null);
+        total += count;
+        if (total > 8192)
+            throw Error('hitl.native.offer-limit');
+        if (!count)
+            break;
+    }
+    try {
+        return JSON.parse(buffer.subarray(0, total).toString('utf8'));
+    }
+    catch {
+        throw Error('hitl.native.offer-invalid');
+    }
+}

package/dist/hitl-native.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeContextSchema = exports.nativeBindingSchema = void 0;
+exports.nativeBinding = nativeBinding;
+exports.nativeKey = nativeKey;
+exports.nativeSignature = nativeSignature;
+exports.nativeMessage = nativeMessage;
+exports.authenticateNative = authenticateNative;
+/** Ingresso v3 exclusivo do callback do host. Nunca exposto como tool do modelo. */
+const node_crypto_1 = require("node:crypto");
+const zod_1 = require("zod");
+const id = zod_1.z.string().min(1).max(200).regex(/^[^\u0000-\u001f]+$/);
+exports.nativeBindingSchema = zod_1.z.object({
+    host: zod_1.z.enum(['hermes', 'openclaw']), installationId: id, connectionId: id,
+    sessionId: id, accountId: id, channelId: id, conversationId: id, personId: id,
+}).strict();
+exports.nativeContextSchema = exports.nativeBindingSchema.extend({
+    messageId: id, context: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+    pedidoSha256: zod_1.z.string().regex(/^[a-f0-9]{64}$/), expiresAt: zod_1.z.string().datetime(),
+}).strict();
+const prefix = (host) => host === 'hermes' ? 'HERMES' : host === 'openclaw' ? 'OPENCLAW' : (() => { throw Error('hitl.native.host'); })();
+/** Configuração privada do processo de ingresso; não é argumento da ferramenta. */
+function nativeBinding(host, env = process.env) {
+    try {
+        const value = exports.nativeBindingSchema.parse(JSON.parse(env[`ORK_HITL_NATIVE_BINDING_${prefix(host)}`] ?? 'null'));
+        if (value.host !== host)
+            throw Error('scope');
+        return value;
+    }
+    catch {
+        throw Error('hitl.native.capability-unavailable');
+    }
+}
+function nativeKey(host, env = process.env) {
+    const key = env[`ORK_HITL_NATIVE_KEY_${prefix(host)}`] ?? '';
+    const other = env[`ORK_HITL_NATIVE_KEY_${host === 'hermes' ? 'OPENCLAW' : 'HERMES'}`];
+    if (Buffer.byteLength(key) < 32 || key === other || key === env.ORK_HITL_INGRESS_KEY_HERMES || key === env.ORK_HITL_INGRESS_KEY_OPENCLAW)
+        throw Error('hitl.native.credentials-unavailable');
+    return key;
+}
+function nativeSignature(thread, pedido, r, key) {
+    const n = exports.nativeContextSchema.parse(r.native);
+    return (0, node_crypto_1.createHmac)('sha256', key).update(JSON.stringify(['ork.hitl-native/v1', thread, pedido,
+        n.host, n.installationId, n.connectionId, n.sessionId, n.accountId, n.channelId,
+        n.conversationId, n.personId, n.messageId, n.context, n.pedidoSha256, n.expiresAt,
+        r.origem, r.canal, r.conta, r.por, r.mensagem, r.recebidoEm, r.resposta])).digest('hex');
+}
+function nativeMessage(n) {
+    return 'native:' + (0, node_crypto_1.createHash)('sha256').update(JSON.stringify([n.host, n.installationId,
+        n.connectionId, n.sessionId, n.channelId, n.accountId, n.conversationId, n.messageId])).digest('hex');
+}
+function authenticateNative(thread, pedido, r, when = new Date().toISOString(), env = process.env) {
+    const n = exports.nativeContextSchema.parse(r.native), binding = nativeBinding(r.canal, env);
+    const age = Date.parse(when) - Date.parse(r.recebidoEm);
+    if (Object.entries(binding).some(([k, v]) => n[k] !== v) ||
+        r.origem !== 'native' || r.conta !== binding.accountId || r.por !== `native:${n.host}:${n.personId}` ||
+        r.mensagem !== nativeMessage(n) || !Number.isFinite(age) || age < 0 || age > 60000 ||
+        !Number.isFinite(Date.parse(n.expiresAt)) || Date.parse(r.recebidoEm) >= Date.parse(n.expiresAt) ||
+        typeof r.resposta !== 'string' || !r.resposta.length || r.resposta.length > 4096 || r.resposta.includes('\0') ||
+        !/^[a-f0-9]{64}$/.test(r.prova ?? ''))
+        throw Error('hitl.native.untrusted');
+    const expected = nativeSignature(thread, pedido, r, nativeKey(n.host, env));
+    if (!(0, node_crypto_1.timingSafeEqual)(Buffer.from(r.prova, 'hex'), Buffer.from(expected, 'hex')))
+        throw Error('hitl.native.untrusted');
+}

package/dist/hitl-presentation.js

@@ -0,0 +1,209 @@
+"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.prazoLocalDoPedido = prazoLocalDoPedido;
+exports.apresentarDecisao = apresentarDecisao;
+exports.apresentarHitl = apresentarHitl;
+exports.pedidoHitlAberto = pedidoHitlAberto;
+exports.ofertaDoPedido = ofertaDoPedido;
+/** D5: preparação determinística e limitada, sem delegar leitura de artefatos ao host. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const thread_1 = require("./thread");
+const estado_thread_1 = require("./estado-thread");
+const claims_1 = require("./claims");
+const ledger_1 = require("./ledger");
+const hitl_1 = require("./hitl");
+const hitl_contract_1 = require("./hitl-contract");
+const hitl_canais_1 = require("./hitl-canais");
+const hitl_native_offer_1 = require("./hitl-native-offer");
+const horario_1 = require("./horario");
+/**
+ * I-35: prazo do pedido no fuso do dono, absoluto e rotulado, para JSON de exibição
+ * (`ork gate context` e `ork_hitl_pending`). `pedido.prazo` continua o ISO assinado.
+ */
+function prazoLocalDoPedido(pedido, agora) {
+    return (0, horario_1.formatarDataHoraRotulada)((0, hitl_contract_1.prazoDoPedido)(pedido), { agora });
+}
+/**
+ * Apresentação não altera o pedido assinado nem escolhe uma resposta pelo humano.
+ *
+ * I-41: as duas versões saem por aqui. O texto de um `ork.hitl/v1` continua byte a byte o de
+ * antes; o que o v2 acrescenta é a consequência de cada alternativa e o porquê da recomendada,
+ * e o que ele troca é o número pela letra. Um `decidido` não passa por aqui de propósito: ele
+ * não tem escolha a oferecer, e montar um diálogo para um fato consumado é pedir ação por engano.
+ */
+function apresentarDecisao(pedido, agora) {
+    (0, hitl_contract_1.validarPedidoHitl)(pedido);
+    const aceita = (0, hitl_contract_1.respostaAceitaDoPedido)(pedido);
+    if (!aceita)
+        throw new Error('decisão informada não tem diálogo: ela não pede nada');
+    const livre = aceita.tipo === 'texto';
+    const escolhas = (0, hitl_contract_1.escolhasDoPedido)(pedido).map(o => ({ const: (0, hitl_contract_1.chaveDaEscolha)(pedido, o.numero), title: (0, hitl_1.redigirSegredos)(o.texto) }));
+    const v2 = (0, hitl_contract_1.ehV2)(pedido) && pedido.classe === 'pergunta' ? pedido : undefined;
+    const expiracao = (0, hitl_contract_1.expiracaoDoPedido)(pedido);
+    const linhas = [
+        `Orkastery · ${pedido.fase}`,
+        `• Decisão: ${(0, hitl_1.redigirSegredos)((0, hitl_contract_1.textoDoPedido)(pedido))}`,
+        `• Recomendo: ${(0, hitl_1.redigirSegredos)((0, hitl_contract_1.recomendacaoDoPedido)(pedido))}`,
+        ...escolhas.flatMap((o, i) => [
+            `  ${o.const}. ${o.title}`,
+            ...(v2 ? [`     → ${(0, hitl_1.redigirSegredos)(v2.alternativas[i].consequencia)}`] : []),
+        ]),
+        livre ? '• Resposta: escreva sua resposta; o texto será enviado literalmente.'
+            : `• Resposta: selecione uma opção no diálogo. Se necessário, digite ${v2 ? 'a letra' : 'o número'}.`,
+        ...(livre && escolhas.length ? ['  Exemplo: digitar “2” envia o texto “2”, sem selecionar a segunda opção.'] : []),
+        `• Prazo: ${(0, horario_1.formatarPrazo)((0, hitl_contract_1.prazoDoPedido)(pedido), { rotulo: true, agora })}. Sem resposta, ${expiracao === 'esperar' ? 'aguardamos' : expiracao === 'seguir-recomendada' ? 'sigo com a recomendada' : 'o pedido será escalado'}.`,
+    ];
+    return { mensagem: linhas.join('\n'), escolhas };
+}
+const limitar = (texto, limite) => {
+    const seguro = (0, hitl_1.redigirSegredos)(texto);
+    return seguro.length > limite ? seguro.slice(0, limite) + '\n[trecho limitado]' : seguro;
+};
+/** Somente arquivos regulares dentro do domicílio canônico; não segue link externo. */
+function lerArtefato(dir, nome) {
+    const arquivo = path.join(dir, nome);
+    try {
+        const real = fs.realpathSync(arquivo);
+        if (!real.startsWith(fs.realpathSync(dir) + path.sep))
+            return '[artefato externo recusado]';
+        const fd = fs.openSync(real, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        try {
+            const stat = fs.fstatSync(fd);
+            if (!stat.isFile() || stat.size > 65536)
+                return '[artefato indisponível ou acima de 64 KiB]';
+            return fs.readFileSync(fd, 'utf8');
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * D1/T6: a profundidade vem do PEDIDO quando ha um; o modo so da o default.
+ *
+ * Antes, o bloco de evidencia era escolhido pelo modo da thread, e nem o emissor nem o dono
+ * tinham como pedir mais evidencia para uma pergunta que precisava dela. Quem chama passa a
+ * profundidade do pedido aberto; sem pedido, o default do modo continua valendo exatamente como
+ * antes, e e por isso que nenhuma superficie que nao conhece pedido muda de comportamento.
+ */
+function apresentarHitl(raiz, id, profundidadeDoPedido) {
+    const t = (0, thread_1.lerThread)(raiz, id), profundidade = profundidadeDoPedido ?? (0, hitl_contract_1.profundidadeDoModo)(t.modo);
+    const dir = (0, thread_1.dirThread)(raiz, id);
+    const artefato = lerArtefato(dir, `${t.faseAtual}.md`) || lerArtefato(dir, `${t.faseAtual.toLowerCase()}.md`);
+    const claims = (0, claims_1.lerClaims)(raiz, id).slice(0, 20).map(c => `${c.id}: ${c.estado}; ${c.alegacao}; verify: ${c.verificar.join(' && ')}`).join('\n');
+    const riscos = artefato.split('\n').filter(l => /risco|limita[cç][aã]o|pend[eê]n|bloque|n[aã]o comprovad/i.test(l)).join('\n');
+    let diff = '[diff indisponível]';
+    const cwd = t.worktree || raiz;
+    try {
+        if ((0, estado_thread_1.raizDoEstado)(cwd) === (0, estado_thread_1.raizDoEstado)(raiz) && /^[a-f0-9]{40}$/.test(t.base.commit)) {
+            const r = (0, node_child_process_1.spawnSync)('git', ['--no-pager', 'diff', '--no-ext-diff', '--no-textconv',
+                ...(profundidade === 'profunda' ? ['--unified=2'] : ['--stat']), t.base.commit, 'HEAD', '--',
+                'core/src', 'adapters', 'scripts', 'docs', 'eval'], { cwd, encoding: 'utf8', timeout: 5000, maxBuffer: 256 * 1024 });
+            if (r.status === 0)
+                diff = r.stdout || '[sem diff de produto]';
+        }
+    }
+    catch { /* falha de consulta permanece explícita */ }
+    return { profundidade, artefato: profundidade === 'resumo' ? '' : limitar(artefato || '[artefato ausente]', profundidade === 'profunda' ? 1200 : 500),
+        claims: limitar(claims || '[claims ausentes]', profundidade === 'resumo' ? 250 : 600),
+        riscos: limitar(riscos || '[riscos não descritos no artefato]', 350),
+        diff: profundidade === 'resumo' ? '' : limitar(diff, profundidade === 'profunda' ? 800 : 350) };
+}
+/** Leitura pura: nunca cria pedido ou aprovação durante uma consulta do pulse. */
+function pedidoHitlAberto(raiz, id, fase, sessionId) {
+    const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
+    const ultimoDespacho = eventos.filter(e => e.tipo === 'phase_dispatch').at(-1)?.ts ?? '';
+    for (const e of [...eventos].reverse()) {
+        if (e.tipo !== 'hitl_requested' || e.ts < ultimoDespacho)
+            continue;
+        try {
+            // I-41 (T4): as duas versoes sao oferecidas, e `decidido` NUNCA. Um fato consumado nao
+            // segura fase, nao tem caminho de resposta e nao pode aparecer como coisa a responder;
+            // `alvoDoPedido` devolve `undefined` para ele, e a linha abaixo o descarta por isso.
+            (0, hitl_contract_1.validarPedidoHitl)(e.pedido);
+            const p = e.pedido;
+            const alvo = (0, hitl_contract_1.alvoDoPedido)(p);
+            if (!alvo)
+                continue;
+            if (p.fase !== fase || (sessionId ? alvo.tipo !== 'session' || alvo.sessionId !== sessionId : alvo.tipo !== 'gate'))
+                continue;
+            if (!eventos.some(r => ['human_gate', 'session_answered'].includes(r.tipo) && r.pedidoId === p.id))
+                return p;
+        }
+        catch { /* pedido inválido não é oferecido como resposta */ }
+    }
+    return undefined;
+}
+/**
+ * FX6: a oferta de canais que acompanha um pedido HITL REAL.
+ *
+ * `ofertaDeCanais` existia desde D12 e era chamada de um lugar so: o canario. No caminho de
+ * producao o humano via a pergunta e um `comandoResposta`, e nada dizia por quais canais dava
+ * para responder AGORA nem por que os outros nao serviam. Uma oferta que so aparece em
+ * simulacao nao e oferta; e uma tabela bonita, como a propria narrativa de D12 admitia.
+ *
+ * As pre-condicoes sao reais e lidas na hora: as variaveis de cada canal saem do ambiente do
+ * processo que esta respondendo a consulta, e `conexoesMcp` traz apenas os hosts com conexao
+ * MCP viva conhecida por quem chama. O Pulse, que roda em cron e nao e uma conexao MCP,
+ * passa a lista vazia de proposito: dizer `disponivel` ali seria inventar uma conexao.
+ */
+function ofertaDoPedido(pedido, conexoesMcp = [], nativo) {
+    (0, hitl_contract_1.validarPedidoHitl)(pedido);
+    const channels = (0, hitl_canais_1.ofertaDeCanais)({ env: process.env, conexoesMcp });
+    if (nativo === undefined)
+        return channels;
+    const proved = (0, hitl_native_offer_1.provenNativeOffer)(pedido, nativo.callback);
+    // Reserva lida na hora da oferta: callback provada não anuncia canal que o ingresso recusaria.
+    // Ledger sem este pedido não prova ausência de reserva.
+    let reserva;
+    try {
+        const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(nativo.raiz, pedido.thread));
+        reserva = eventos.some(e => e.tipo === 'hitl_requested' && e.pedido?.id === pedido.id)
+            ? (0, hitl_canais_1.reservaDoPedido)(eventos, pedido.id) : 'hitl.channel.unverified';
+    }
+    catch {
+        reserva = 'hitl.channel.unverified';
+    }
+    return [...channels, ...['hermes', 'openclaw'].map(host => {
+            const oferta = (0, hitl_canais_1.ofertaNativa)(host, proved === host);
+            return oferta.estado === 'disponivel' && reserva ? { ...oferta, estado: 'indisponivel', motivo: reserva } : oferta;
+        })];
+}