@orkastery/cli 0.2.0 → 0.4.1

package/dist/hitl-public-receipt.js

@@ -0,0 +1,176 @@
+"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.ENV_HITL_VERIFIERS = void 0;
+exports.publicHitlVerifiers = publicHitlVerifiers;
+exports.publicReceiptAuthority = publicReceiptAuthority;
+exports.publicBindingMatches = publicBindingMatches;
+exports.signPublicReceipt = signPublicReceipt;
+exports.verifyPublicReceipt = verifyPublicReceipt;
+/** Prova pública de recibos: a chave de ingresso permanece no host confiável.
+ * A raiz de confiança vem do ambiente de startup, nunca do recibo ou de toolargs.
+ * O filho pode verificar provas, mas não emitir uma para outros bytes/identidades.
+ */
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const zod_1 = require("zod");
+const hitl_native_1 = require("./hitl-native");
+exports.ENV_HITL_VERIFIERS = 'ORK_RECEIPT_VERIFIERS';
+const slots = ['telegram:legacy', 'telegram:hermes', 'telegram:openclaw', 'native:hermes', 'native:openclaw'];
+const sha = (v) => (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(v)).digest('hex');
+const verifierSchema = zod_1.z.object({ publicKey: zod_1.z.string().max(128), bindingSha256: zod_1.z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+const bundleSchema = zod_1.z.object({ schema: zod_1.z.literal('ork.hitl-verifiers/v1'),
+    verifiers: zod_1.z.record(zod_1.z.enum(slots), verifierSchema) }).strict();
+const slotFor = (canal, native) => {
+    const slot = `${native ? 'native' : 'telegram'}:${canal ?? 'legacy'}`;
+    if (!slots.includes(slot))
+        throw Error('hitl.receipt.authority');
+    return slot;
+};
+function material(slot, env) {
+    if (slot.startsWith('native:')) {
+        const host = slot.slice(7);
+        return { key: (0, hitl_native_1.nativeKey)(host, env), binding: (0, hitl_native_1.nativeBinding)(host, env) };
+    }
+    const host = slot.slice(9), suffix = host === 'legacy' ? '' : `_${host.toUpperCase()}`;
+    const key = env[`ORK_HITL_INGRESS_KEY${suffix}`] ?? '';
+    if (Buffer.byteLength(key) < 32 || (host !== 'legacy' && key === env[`ORK_HITL_INGRESS_KEY_${host === 'hermes' ? 'OPENCLAW' : 'HERMES'}`]))
+        throw Error('hitl.receipt.credentials');
+    const binding = host === 'openclaw' ? env.ORK_HITL_OPENCLAW_ACCOUNT?.trim() : null;
+    if (host === 'openclaw' && !binding)
+        throw Error('hitl.receipt.credentials');
+    return { key, binding };
+}
+function signingKey(key, slot) {
+    const seed = (0, node_crypto_1.createHmac)('sha256', key).update(`ork.hitl-public-receipt/v1:${slot}`).digest();
+    return (0, node_crypto_1.createPrivateKey)({ key: Buffer.concat([Buffer.from('302e020100300506032b657004220420', 'hex'), seed]),
+        format: 'der', type: 'pkcs8' });
+}
+function inherited(env) {
+    const raw = env[exports.ENV_HITL_VERIFIERS];
+    if (!raw)
+        return {};
+    if (Buffer.byteLength(raw) > 4096)
+        throw Error('hitl.receipt.verifiers-invalid');
+    return bundleSchema.parse(JSON.parse(raw)).verifiers;
+}
+/** Somente material público; é seguro transportar em config/env do filho. */
+function publicHitlVerifiers(env = process.env) {
+    const verifiers = inherited(env);
+    for (const slot of slots) {
+        const host = slot.split(':')[1];
+        const name = slot.startsWith('native:') ? `ORK_HITL_NATIVE_KEY_${host.toUpperCase()}` :
+            `ORK_HITL_INGRESS_KEY${host === 'legacy' ? '' : `_${host.toUpperCase()}`}`;
+        // Configuração privada presente prevalece: chave inválida/rotacionada não cai
+        // silenciosamente num verificador público herdado da configuração anterior.
+        if (env[name] !== undefined) {
+            delete verifiers[slot];
+            try {
+                const m = material(slot, env);
+                verifiers[slot] = { publicKey: (0, node_crypto_1.createPublicKey)(signingKey(m.key, slot)).export({ format: 'der', type: 'spki' }).toString('base64'),
+                    bindingSha256: sha(m.binding) };
+            }
+            catch { /* canal não provisionado não ganha autoridade de verificação */ }
+        }
+    }
+    return Object.keys(verifiers).length ? JSON.stringify({ schema: 'ork.hitl-verifiers/v1', verifiers }) : undefined;
+}
+function publicReceiptAuthority(canal, native) {
+    return inherited(process.env)[slotFor(canal, native)];
+}
+function publicBindingMatches(authority, binding) {
+    return authority.bindingSha256 === sha(binding);
+}
+/** Sidecar aditivo: recibo HMAC original e hash do ledger permanecem intactos. */
+function signPublicReceipt(file, canal, native) {
+    const slot = slotFor(canal, native), m = material(slot, process.env);
+    const bytes = readRegular(file, 1048576);
+    const receipt = JSON.parse(bytes.toString('utf8'));
+    if (!/^[a-f0-9]{64}$/.test(receipt.assinatura ?? '') || !(0, node_crypto_1.timingSafeEqual)(Buffer.from(receipt.assinatura, 'hex'), (0, node_crypto_1.createHmac)('sha256', m.key).update(JSON.stringify(receipt.dados)).digest()))
+        throw Error('hitl.receipt.mac-invalid');
+    const proof = JSON.stringify({ schema: 'ork.hitl-public-receipt/v1',
+        signature: (0, node_crypto_1.sign)(null, bytes, signingKey(m.key, slot)).toString('base64') });
+    const proofFile = `${file}.public`;
+    const temporary = path.join(path.dirname(file), `${(0, node_crypto_1.randomUUID)()}.public.tmp`);
+    const fd = fs.openSync(temporary, 'wx', 0o600);
+    try {
+        fs.writeFileSync(fd, proof);
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    try {
+        try {
+            fs.linkSync(temporary, proofFile);
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+        }
+        const dir = fs.openSync(path.dirname(file), 'r');
+        try {
+            fs.fsyncSync(dir);
+        }
+        finally {
+            fs.closeSync(dir);
+        }
+    }
+    finally {
+        fs.unlinkSync(temporary);
+    }
+    // Não substitui um sidecar divergente ou symlink encontrado no estado.
+    if (readRegular(proofFile, 1024).toString('utf8') !== proof)
+        throw Error('hitl.receipt.proof-conflict');
+}
+function readRegular(file, max) {
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.nlink !== 1 || st.uid !== process.getuid?.() || (st.mode & 0o777) !== 0o600 || st.size > max)
+            throw Error('hitl.receipt.proof-invalid');
+        return fs.readFileSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function verifyPublicReceipt(file, bytes, authority) {
+    const proof = zod_1.z.object({ schema: zod_1.z.literal('ork.hitl-public-receipt/v1'),
+        signature: zod_1.z.string().regex(/^[A-Za-z0-9+/]{86}==$/) }).strict().parse(JSON.parse(readRegular(`${file}.public`, 1024).toString('utf8')));
+    const key = (0, node_crypto_1.createPublicKey)({ key: Buffer.from(authority.publicKey, 'base64'), format: 'der', type: 'spki' });
+    return key.asymmetricKeyType === 'ed25519' && (0, node_crypto_1.verify)(null, bytes, key, Buffer.from(proof.signature, 'base64'));
+}

package/dist/hitl-resumo.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEM_PERGUNTA_NO_RESUMO = exports.TETO_DE_DECISOES_DETALHADAS = exports.TETO_DE_ESPERAS_POR_MAQUINA = exports.TETO_DE_THREADS_NOMEADAS = exports.PERGUNTA_DO_RESUMO = exports.CONTRATO_RESUMO = void 0;
+exports.resumirHitl = resumirHitl;
+exports.linhasDasOutrasMaquinas = linhasDasOutrasMaquinas;
+exports.linhasDasDecisoes = linhasDasDecisoes;
+exports.linhaDasPerguntas = linhaDasPerguntas;
+exports.linhaDosConsertos = linhaDosConsertos;
+exports.nomearThreads = nomearThreads;
+exports.linhaDoLoteGuardado = linhaDoLoteGuardado;
+exports.textoDoResumo = textoDoResumo;
+/**
+ * I-41 (D16), CAMADA 1: o resumo recorrente. UMA mensagem, nunca uma por item.
+ *
+ * Em 20/09 as 16:00 o cron religado disparou e a entrega mandou 75 mensagens em minutos no
+ * Telegram do dono, uma por item. A frase dele foi "de uma forma que humanos simplesmente nao
+ * compreendem". A causa nao era volume de perguntas: era `varrerPulse` mandar uma mensagem por
+ * item novo. A camada 1 troca isso por um resumo: quantos pendentes, quantos urgentes, quantos
+ * travando alguma coisa (e quais), quantos sem volta, e uma pergunta no fim.
+ *
+ * Quem monta a mensagem e ESTE modulo, no nucleo. Os quatro hosts homologados transportam texto
+ * pronto. Se um deles precisasse decidir como escrever um numero, a decisao estaria no arquivo
+ * errado, e o dono veria uma coisa no Claude Code e outra no Telegram.
+ *
+ * O texto para humano nunca sai em JSON. `resumirHitl` devolve dados; `textoDoResumo` devolve a
+ * mensagem do canal. Quem entrega chama a segunda.
+ */
+const horario_1 = require("./horario");
+const decisao_autonoma_1 = require("./decisao-autonoma");
+const hitl_classificacao_1 = require("./hitl-classificacao");
+exports.CONTRATO_RESUMO = 'ork.hitl-resumo/v1';
+/** A pergunta final, palavra por palavra como o dono a escreveu. */
+exports.PERGUNTA_DO_RESUMO = 'Posso te mandar as perguntas agora?';
+/**
+ * Quantos nomes curtos de thread cabem no texto antes do "e mais N".
+ *
+ * Nomear dezoito threads numa mensagem de Telegram devolve o problema pelo outro lado: a
+ * mensagem vira uma lista longa de novo. Cinco nomes cabem em duas linhas e o resto vira
+ * contagem; o comando que mostra todas fica na ultima linha.
+ */
+exports.TETO_DE_THREADS_NOMEADAS = 5;
+function resumirHitl(itens, opcoes) {
+    const janelaMin = opcoes.janelaMin ?? hitl_classificacao_1.JANELA_PADRAO_MIN;
+    const contagem = (0, hitl_classificacao_1.contarClassificacoes)(itens, { quando: opcoes.quando, janelaMin, atoDoItem: opcoes.atoDoItem });
+    const prontas = opcoes.prontas ?? 0;
+    return {
+        contrato: exports.CONTRATO_RESUMO, consultadoEm: opcoes.quando, janelaMin, ...contagem,
+        prontas, acumuladas: Math.min(opcoes.acumuladas ?? 0, prontas), consertos: opcoes.consertos ?? 0,
+        pergunta: prontas > 0 ? exports.PERGUNTA_DO_RESUMO : null,
+        decisoes: [...(opcoes.decisoes ?? [])], acimaDoLimiar: [...(opcoes.acimaDoLimiar ?? [])],
+        ...(opcoes.outrasMaquinas?.length ? { outrasMaquinas: opcoes.outrasMaquinas.map(m => ({ ...m, esperando: [...m.esperando] })) } : {}),
+    };
+}
+/** Quantas threads de outra maquina o resumo nomeia antes de contar o resto. */
+exports.TETO_DE_ESPERAS_POR_MAQUINA = 3;
+/**
+ * I-51 (RM-047): as linhas das outras maquinas, as mesmas nos dois canais. Informam; a resposta e
+ * na maquina onde a thread vive.
+ */
+function linhasDasOutrasMaquinas(r, marcador, recuo) {
+    const outras = r.outrasMaquinas ?? [];
+    if (!outras.length)
+        return [];
+    const linhas = [`${marcador}Em outras máquinas:`];
+    for (const m of outras) {
+        const esperando = m.esperando.length;
+        linhas.push(`${recuo}${m.maquina}: ${m.ativas} ${m.ativas === 1 ? 'thread ativa' : 'threads ativas'}` +
+            (esperando ? `; esperando você em ${esperando} (responda lá)` : ''));
+        const mostradas = m.esperando.slice(0, exports.TETO_DE_ESPERAS_POR_MAQUINA), sobra = esperando - mostradas.length;
+        for (const e of mostradas)
+            linhas.push(`${recuo}  • ${e.thread} ${e.fase}${e.pergunta ? `: ${uma(e.pergunta, 80)}` : ''}`);
+        if (sobra > 0)
+            linhas.push(`${recuo}  e mais ${sobra}: ork fabrica`);
+    }
+    return linhas;
+}
+/** Quantas decisoes o texto detalha antes de contar o resto: o resumo continua sendo UMA mensagem. */
+exports.TETO_DE_DECISOES_DETALHADAS = 3;
+/** Uma linha cortada no teto de uma linha de Telegram, sem quebra. */
+const uma = (texto, teto = 160) => {
+    const limpo = String(texto).replace(/\s+/g, ' ').trim();
+    return limpo.length > teto ? `${limpo.slice(0, teto - 3)}...` : limpo;
+};
+/**
+ * As linhas das decisoes tomadas sem perguntar, as mesmas nos dois canais (so o recuo e o marcador
+ * mudam). Efeito antes de mecanismo: primeiro o que foi decidido, depois o porque e o preco.
+ */
+function linhasDasDecisoes(r, marcador, recuo) {
+    if (!r.decisoes.length && !r.acimaDoLimiar.length)
+        return [];
+    const mostradas = r.decisoes.slice(-exports.TETO_DE_DECISOES_DETALHADAS), sobra = r.decisoes.length - mostradas.length;
+    return [
+        ...(r.decisoes.length ? [`${marcador}Decidi sem te perguntar: ${r.decisoes.length}`] : []),
+        ...mostradas.flatMap(d => [
+            `${recuo}• ${d.thread} ${d.fase}: ${uma(d.decidido)}`,
+            `${recuo}  porquê: ${uma(d.porque, 120)}. Para mudar: ${uma(d.comoMudar, 120)}.`,
+            `${recuo}  reverter agora: ${uma(d.custoDeReverter.agora, 80)}; depois: ${uma(d.custoDeReverter.depois, 80)}.`,
+        ]),
+        ...(sobra > 0 ? [`${recuo}e mais ${sobra}: ork decisao placar <thread>`] : []),
+        ...r.acimaDoLimiar.map(f => `${recuo}${marcador ? '⚠️ ' : '! '}${f.thread} ${f.fase} já tomou ${f.decididas} decisões sozinha, ` +
+            `acima do limiar de ${decisao_autonoma_1.LIMIAR_DE_DECISOES_POR_FASE}: vale revisar.`),
+    ];
+}
+/** Quando nao ha pergunta, o resumo diz isso em vez de pedir licenca para mandar nada. */
+exports.SEM_PERGUNTA_NO_RESUMO = 'Nada aqui pede resposta sua por este canal agora.';
+/** A linha das perguntas prontas, uma so para os dois canais, pelo mesmo motivo da de baixo. */
+function linhaDasPerguntas(n) {
+    return `Perguntas para você: ${n}`;
+}
+/** A linha dos pedidos que nao viraram pergunta, com a concordancia certa (A5). */
+function linhaDosConsertos(n) {
+    return n === 1
+        ? '1 pedido não virou pergunta; o conserto é nosso, não seu.'
+        : `${n} pedidos não viraram pergunta; o conserto é nosso, não seu.`;
+}
+/**
+ * Os nomes curtos que entram no texto, mais a sobra contada.
+ *
+ * O nome curto e o `id` da thread, que e o que o dono ja le em `ork board`. O nome longo
+ * ("I-41 HITL invertido: decisao tomada, lote e pergunta rara") e titulo, nao endereco.
+ */
+function nomearThreads(threads, teto = exports.TETO_DE_THREADS_NOMEADAS) {
+    if (threads.length === 0)
+        return '';
+    const mostradas = threads.slice(0, teto), sobra = threads.length - mostradas.length;
+    return mostradas.join(', ') + (sobra > 0 ? ` e mais ${sobra}` : '');
+}
+/**
+ * A frase do lote guardado, uma so para os dois canais.
+ *
+ * Ela existe em um lugar de proposito: se cada canal escrevesse a sua, o dono leria uma coisa no
+ * Telegram e outra no terminal, e a paridade que o nucleo existe para garantir se perderia na
+ * primeira frase que alguem achou que podia melhorar so de um lado.
+ */
+function linhaDoLoteGuardado(n) {
+    return n === 1
+        ? '1 pergunta continua guardada desde o resumo anterior.'
+        : `${n} perguntas continuam guardadas desde o resumo anterior.`;
+}
+/** Como o humano responde. Letra ou palavra curta; nunca identificador longo para colar. */
+function linhaDeResposta(codigo) {
+    return codigo
+        ? [`Responda com ${codigo} a (sim) ou ${codigo} b (agora não).`]
+        : ['Responda: a (sim) ou b (agora não).'];
+}
+/** O fecho do resumo: a pergunta do dono quando ha o que mandar, e a frase honesta quando nao ha. */
+function fecho(r, codigo) {
+    return r.pergunta ? [r.pergunta, ...linhaDeResposta(codigo)] : [exports.SEM_PERGUNTA_NO_RESUMO];
+}
+function textoTelegram(r, codigo) {
+    const quando = (0, horario_1.formatarDataHoraRotulada)(r.consultadoEm, { agora: r.consultadoEm });
+    const linhas = [
+        `🔔 Orkastery, resumo de ${quando}`,
+        '',
+        `Esperando você: ${r.total}`,
+        `⏱ Urgentes: ${r.urgentes}`,
+        `⛔ Travando o avanço: ${r.bloqueantes}${r.threadsBloqueadas.length ? `, em ${r.threadsBloqueadas.length} threads` : ''}`,
+        ...(r.threadsBloqueadas.length ? [`   ${nomearThreads(r.threadsBloqueadas)}`] : []),
+        `🔒 Sem volta depois de feito: ${r.criticos}`,
+        `❓ ${linhaDasPerguntas(r.prontas)}`,
+        ...(r.consertos ? [`🔧 ${linhaDosConsertos(r.consertos)}`] : []),
+        ...(r.acumuladas ? ['', `📥 ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
+        ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '🧭 ', '   ')] : []),
+        ...(r.outrasMaquinas?.length ? ['', ...linhasDasOutrasMaquinas(r, '🖥️ ', '   ')] : []),
+        '',
+        ...fecho(r, codigo),
+    ];
+    return linhas.join('\n');
+}
+function textoTerminal(r, codigo) {
+    const quando = (0, horario_1.formatarDataHoraRotulada)(r.consultadoEm, { agora: r.consultadoEm });
+    const celulas = [
+        ['esperando você', r.total],
+        ['urgentes', r.urgentes],
+        ['travando o avanço', r.bloqueantes],
+        ['sem volta depois de feito', r.criticos],
+        ['perguntas para você', r.prontas],
+    ];
+    const largura = Math.max(...celulas.map(([nome]) => nome.length));
+    const numero = Math.max(7, ...celulas.map(([, n]) => String(n).length));
+    const regua = `  ${'-'.repeat(largura)}  ${'-'.repeat(numero)}`;
+    const linhas = [
+        `Orkastery, resumo de ${quando}`,
+        '',
+        `  ${'o que'.padEnd(largura)}  ${'quantos'.padStart(numero)}`,
+        regua,
+        ...celulas.map(([nome, n]) => `  ${nome.padEnd(largura)}  ${String(n).padStart(numero)}`),
+        ...(r.threadsBloqueadas.length
+            ? ['', `  threads travadas (${r.threadsBloqueadas.length}): ${nomearThreads(r.threadsBloqueadas)}`] : []),
+        ...(r.consertos ? ['', `  ${linhaDosConsertos(r.consertos)}`] : []),
+        ...(r.acumuladas ? ['', `  ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
+        ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '', '  ').map(l => l.startsWith('  ') ? l : `  ${l}`)] : []),
+        ...(r.outrasMaquinas?.length ? ['', ...linhasDasOutrasMaquinas(r, '', '  ').map(l => l.startsWith('  ') ? l : `  ${l}`)] : []),
+        '',
+        ...fecho(r, codigo),
+    ];
+    return linhas.join('\n');
+}
+/**
+ * A mensagem do canal. Nunca JSON: o dono le texto, e o Telegram nao formata objeto.
+ *
+ * `codigo` e o codigo curto do pedido de consentimento, quando ja existe um. Sem ele o texto
+ * ainda sai completo e diz como responder; o que nunca aparece e identificador longo para colar.
+ */
+function textoDoResumo(resumo, opcoes) {
+    if (resumo.contrato !== exports.CONTRATO_RESUMO)
+        throw new Error('resumo HITL: contrato inválido');
+    return opcoes.canal === 'telegram' ? textoTelegram(resumo, opcoes.codigo) : textoTerminal(resumo, opcoes.codigo);
+}