@orkastery/cli 0.2.0 → 0.4.1

package/dist/prompts.js

@@ -160,7 +160,7 @@ exports.SECOES_OBRIGATORIAS = [
     '## Pedido do builder',
     '## Regras de evidencia',
 ];
-/** A frase que nenhum template pode perder, porque ela e o contrato dos 5 modos. */
+/** A frase que nenhum template pode perder, porque ela e o contrato de todo modo. */
 exports.REGRA_CENTRAL = 'REGRA CENTRAL: o modo afrouxa a pausa, NUNCA a verificacao.';
 /** O contrato do prompt de fase (o do B4). */
 exports.CONTRATO_DE_FASE = {
@@ -241,18 +241,29 @@ function lintTemplate(t, contrato = exports.CONTRATO_DE_FASE) {
  *
  * Ele e a fonte de verdade do prompt do `ork` e a copia versionada em `prompts/fase-padrao.md`
  * precisa ser identica byte a byte (ha teste que prova isso). Renderizado, ele produz
- * exatamente o prompt que o B0 montava por concatenacao: mudar o texto aqui e mudar contrato.
+ * o contrato distribuido a projetos sem override; mudar o texto exige sincronizar a copia.
  */
 exports.TEMPLATE_FASE_PADRAO = `---
 id: fase-padrao
-versao: 2
+versao: 3
 descricao: Prompt canonico de uma fase do ciclo GOAL..MASTER, com nomenclatura, modo de conducao, contexto da thread, memoria injetada e regras de evidencia.
 fases: [GOAL, PLAN, GO, CHECK, SHIP, MASTER]
 variaveis: [fase, thread, bloco, nome, ciclo_canonico, tag, blocos, pausas, linha_variante, regra_de_pausa, invariantes, slug, projeto_nome, projeto_abbrev, base_branch, base_commit, diretorio, pedido, memoria_injetada, regras_de_evidencia]
 ---
 # Orkastery, fase {{fase}} da thread {{thread}}
 
-Voce conduz o bloco {{bloco}} da thread "{{nome}}".
+Voce conduz o bloco {{bloco}} da thread "{{nome}}". {{fase}} e a fase de entrada, nao uma nova orquestracao.
+Execute as fases deste bloco na ordem canonica, respeitando o escopo de cada fase e os gates do nucleo; GOAL nao implementa antes de GO.
+Nao abra outra thread nem redespache a si mesmo. Se houver MCP do projeto, prefira suas ferramentas para estado e operacoes suportadas.
+No Claude com servidor \`orkastery\`, use nomes completos expostos: \`ToolSearch\` com \`select:mcp__orkastery__ork_thread_status,mcp__orkastery__ork_artifact_read\` descobre essas leituras; para outra ferramenta, selecione seu nome completo. Nao busque \`select:ork_thread_status\`. Outros hosts usam seu namespace descoberto.
+Quando disponiveis, use ork_artifact_read/write para objetivo, plano e parecer, e ork_claims_list/ork_claim_add para claims; nao escreva ledger nem estado canonico diretamente.
+Decisao que voce tomar sem perguntar ao dono vai ao ledger por \`ork decisao registrar <thread>\`, com o que foi decidido, o porque, como mudar, o custo de reverter agora e depois, o criterio escrito, quem decidiu e a evidencia; e assim que ela chega ao dono no resumo, em vez de sumir na conversa.
+Artefato de autoria do agente nao e recibo oficial; cadastrar claim nao significa verifica-la.
+Para registrar produto, prefira ork_git_commit com HEAD atual e paths com claims; use ork_verify para verificacao real e ork_ship com HEADs fonte/destino conferidos para entrega. Commit local nao e SHIP; retorno incomplete exige reconciliar estado e remoto antes de repetir. Permissao para consultar nao concede essas operacoes: respeite a autorizacao nativa e os gates.
+Decisao do dono deve ser apresentada pela sessao condutora ao host; a sessao filha nao responde nem assume a identidade do dono.
+Preserve o perfil filho configurado: \`interactive\` concede consultas; \`worktree\` exige opt-in da instalacao e autoriza ferramentas exatas na WT validada, sem aprovar gates ou assumir o dono. Nao mude configuracao para contornar bloqueio.
+Consulte \`ork_git_status\` para HEADs reais e estado Git; use \`ork_git_commit\`, \`ork_verify\` e \`ork_ship\` pelos contratos do nucleo, sem Bash Git nem inventar SHAs. Use \`source.head\` como \`expectedHead\` do commit; consulte novamente apos commit e use \`source.head\`/\`destination.head\` como \`expectedSource\`/\`expectedDestination\` do SHIP. Base historica nao substitui a consulta atual. As regras Edit/deny sao permissoes nativas de ferramentas, nao sandbox de processos.
+Permissao nativa ou operacao sem transporte suportado continua um impedimento real, nunca motivo para alterar o sandbox.
 
 ## Ciclo canonico
 {{ciclo_canonico}}
@@ -278,6 +289,14 @@ REGRA CENTRAL: o modo afrouxa a pausa, NUNCA a verificacao.
 {{pedido}}
 {{memoria_injetada}}
 
+## Isolamento por sessão
+
+O runtime pode ser o mesmo da condutora e do revisor. A independência exige IDs nativos
+distintos e vínculos comprovados pelo núcleo; nome de papel no prompt não é autoridade.
+Esta sessão executa o bloco recebido, sem abrir recursão, aprovar gate ou validar o próprio
+trabalho. Preserve runtime/modelo/esforço e perfil \`interactive\`/\`worktree\` já configurados.
+Falha de autenticação permanece impedimento; não troque provider, sandbox ou identidade.
+
 ## Regras de evidencia
 {{regras_de_evidencia}}`;
 /** Os templates que vem dentro do `ork`, por id. */
@@ -387,7 +406,8 @@ function threadDeExemplo(modo, fase, projeto) {
         nome: 'exemplo de prompt',
         assunto: 'exemplo',
         modo,
-        fases: [...types_1.FASES],
+        // I-42: as fases saem dos blocos do modo; no `#Fast` e so a GO.
+        fases: def.blocos.flatMap((b) => b.fases),
         blocos: def.blocos,
         faseAtual: fase,
         status: 'aberta',

package/dist/prova-minima.js

@@ -0,0 +1,112 @@
+"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.LIMITE_DE_COMANDOS_SEM_CHECK = void 0;
+exports.cicloSemCheck = cicloSemCheck;
+exports.testeFocado = testeFocado;
+exports.comandoDoTesteFocado = comandoDoTesteFocado;
+exports.validarProvaSemCheck = validarProvaSemCheck;
+exports.registrarProvaAusente = registrarProvaAusente;
+/**
+ * I-42 (D4, D5): a prova minima de um ciclo sem CHECK, em tres degraus.
+ *
+ *  1. Teste focado: havendo teste homonimo para algum caminho do commit (ou sendo o caminho um
+ *     teste), roda so ele e grava comando e codigo de saida.
+ *  2. Claim retrospectiva: sem teste homonimo, uma claim de uma linha com ate dois comandos
+ *     baratos. O nucleo recusa claim que rode a suite inteira do manifesto (custo medido na I-42:
+ *     227,6 s contra ~12 s do teste focado).
+ *  3. Ausencia declarada: sem teste nem comando honesto, o evento `prova_ausente` registra os
+ *     caminhos sem prova e o motivo. Nao ha prova fingida e nao ha ausencia em silencio.
+ *
+ * O que nao acontece em degrau nenhum: baseline do manifesto ou a suite completa.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+/** Teto de comandos por claim num ciclo sem CHECK (degrau 2). */
+exports.LIMITE_DE_COMANDOS_SEM_CHECK = 2;
+/** O ciclo da thread nao tem CHECK: a prova e a minima, feita pela propria GO. */
+function cicloSemCheck(thread) {
+    return !thread.blocos.some((b) => b.fases.includes('CHECK'));
+}
+/**
+ * O teste focado de um caminho, por convencao: `core/src/X.ts` -> `core/test/X.test.ts`, e um
+ * `core/test/X.test.ts` e o proprio teste. Devolve o caminho do teste, ou null quando nao ha.
+ */
+function testeFocado(raiz, caminho) {
+    const c = caminho.replace(/\\/g, '/');
+    if (/^core\/test\/[^/]+\.test\.ts$/.test(c))
+        return fs.existsSync(path.join(raiz, c)) ? c : null;
+    const m = /^core\/src\/([^/]+)\.ts$/.exec(c);
+    if (!m)
+        return null;
+    const teste = `core/test/${m[1]}.test.ts`;
+    return fs.existsSync(path.join(raiz, teste)) ? teste : null;
+}
+/** O comando que roda so o teste focado (degrau 1). */
+function comandoDoTesteFocado(teste) {
+    const nome = path.basename(teste).replace(/\.ts$/, '.js');
+    return `npm --prefix core run build:test && node --test core/dist-test/test/${nome}`;
+}
+/**
+ * Recusa a claim que fura o degrau 2: mais comandos do que o teto, ou a suite inteira do
+ * manifesto. Mensagem tipada, com a saida certa.
+ */
+function validarProvaSemCheck(verificar, comandoDeTesteDoManifesto) {
+    if (verificar.length > exports.LIMITE_DE_COMANDOS_SEM_CHECK) {
+        throw new Error(`claims.custo: ciclo sem CHECK aceita ate ${exports.LIMITE_DE_COMANDOS_SEM_CHECK} comandos por claim ` +
+            `(recebidos ${verificar.length}); use o teste focado ou declare a ausencia com ork claims ausente`);
+    }
+    const suite = comandoDeTesteDoManifesto?.trim();
+    if (suite && verificar.some((c) => c.includes(suite))) {
+        throw new Error(`claims.custo: ciclo sem CHECK nao roda a suite inteira ("${suite}"); ` +
+            'use o teste focado do arquivo que mudou');
+    }
+}
+/** Degrau 3: grava no ledger da thread que estes caminhos ficaram sem prova, e por que. */
+function registrarProvaAusente(raiz, threadId, ausencia) {
+    (0, thread_1.lerThread)(raiz, threadId); // a thread tem de existir
+    const motivo = ausencia.motivo.trim();
+    if (!motivo)
+        throw new Error('prova.ausente: o motivo e obrigatorio (uma linha)');
+    if (ausencia.paths.length === 0)
+        throw new Error('prova.ausente: informe os caminhos que ficaram sem prova');
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.provaAusente, {
+        paths: ausencia.paths,
+        motivo,
+        ...(ausencia.commit ? { commit: ausencia.commit } : {}),
+    });
+}

package/dist/pulse-cadencia.js

@@ -0,0 +1,163 @@
+"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.CADENCIA_PADRAO = exports.CADENCIAS = exports.CONTRATO_CADENCIA = void 0;
+exports.extrairTagDoPulse = extrairTagDoPulse;
+exports.lerCadencia = lerCadencia;
+exports.gravarCadencia = gravarCadencia;
+exports.janelaDoInstante = janelaDoInstante;
+exports.inicioDaProximaJanela = inicioDaProximaJanela;
+exports.lerUltimoResumo = lerUltimoResumo;
+exports.gravarUltimoResumo = gravarUltimoResumo;
+exports.janelaAberta = janelaAberta;
+exports.textoDaCadencia = textoDaCadencia;
+/**
+ * I-50 (RM-039): a cadencia do resumo do pulse, trocada pelo dono em conversa com uma tag.
+ *
+ * As tags sao as que o dono definiu:
+ *   `#OrkPulseOff`      de 8 em 8 horas, ancorado as 08h do fuso dono (08h, 16h e 00h);
+ *   `#OrkPulseOn`       de 2 em 2 horas;
+ *   `#OrkPulseOn-15m`, `-30m` e `-60m`: de 15, 30 ou 60 minutos.
+ *
+ * O cron bate em intervalo curto e quem decide se ESTA batida entrega e o nucleo, lendo a
+ * cadencia duravel em `.orkastery/monitor/pulse-cadencia.json`. Assim a troca de tag vale na
+ * proxima batida, sem editar o crontab. A cadencia governa o status periodico; pergunta de
+ * verdade ao dono nao espera janela nenhuma e sai na hora.
+ *
+ * Cada cadencia divide o dia do dono em janelas ancoradas (15m em :00, :15, :30 e :45; 2h nas
+ * horas pares; 8h as 08h, 16h e 00h). Entrega-se no maximo uma vez por janela.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const horario_1 = require("./horario");
+const estado_thread_1 = require("./estado-thread");
+exports.CONTRATO_CADENCIA = 'ork.pulse-cadencia/v1';
+const ARQUIVO_CADENCIA = 'pulse-cadencia.json';
+const ARQUIVO_ULTIMO_RESUMO = 'pulse-ultimo-resumo.json';
+exports.CADENCIAS = {
+    '#OrkPulseOff': { tag: '#OrkPulseOff', janelaMin: 480, ancoraMin: 8 * 60, descricao: 'de 8 em 8 horas, as 08h, 16h e 00h' },
+    '#OrkPulseOn': { tag: '#OrkPulseOn', janelaMin: 120, ancoraMin: 0, descricao: 'de 2 em 2 horas' },
+    '#OrkPulseOn-15m': { tag: '#OrkPulseOn-15m', janelaMin: 15, ancoraMin: 0, descricao: 'de 15 em 15 minutos' },
+    '#OrkPulseOn-30m': { tag: '#OrkPulseOn-30m', janelaMin: 30, ancoraMin: 0, descricao: 'de 30 em 30 minutos' },
+    '#OrkPulseOn-60m': { tag: '#OrkPulseOn-60m', janelaMin: 60, ancoraMin: 0, descricao: 'de hora em hora' },
+};
+/** Sem tag gravada, vale a hora cheia: o pedido do dono em 20/09/2026. */
+exports.CADENCIA_PADRAO = '#OrkPulseOn-60m';
+/** A primeira tag de pulse do texto, em qualquer canal; `null` quando nao ha. */
+function extrairTagDoPulse(texto) {
+    if (typeof texto !== 'string')
+        return null;
+    const m = /#OrkPulse(On|Off)(?:-(15|30|60)m)?(?![\w-])/i.exec(texto);
+    if (!m)
+        return null;
+    if (m[1].toLowerCase() === 'off')
+        return m[2] ? null : '#OrkPulseOff';
+    return m[2] ? `#OrkPulseOn-${m[2]}m` : '#OrkPulseOn';
+}
+const dirDoMonitor = (raiz, estadoDir) => estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor');
+/** A cadencia em vigor: a gravada pelo dono, ou a padrao. Arquivo ilegivel vale a padrao. */
+function lerCadencia(raiz, estadoDir) {
+    try {
+        const bruto = JSON.parse(fs.readFileSync(path.join(dirDoMonitor(raiz, estadoDir), ARQUIVO_CADENCIA), 'utf8'));
+        if (bruto.contrato === exports.CONTRATO_CADENCIA && Object.hasOwn(exports.CADENCIAS, bruto.tag))
+            return { ...exports.CADENCIAS[bruto.tag], gravada: bruto };
+    }
+    catch { /* sem cadencia gravada: vale a padrao */ }
+    return { ...exports.CADENCIAS[exports.CADENCIA_PADRAO], gravada: null };
+}
+/** Grava a tag do dono. `por` e quem mandou (o remetente autenticado do canal, ou o operador). */
+function gravarCadencia(raiz, tag, origem, estadoDir) {
+    if (!Object.hasOwn(exports.CADENCIAS, tag))
+        throw new Error(`pulse.cadencia: tag desconhecida ${tag}`);
+    const por = origem.por.trim();
+    if (!por)
+        throw new Error('pulse.cadencia: informe quem trocou a cadencia');
+    const gravada = { contrato: exports.CONTRATO_CADENCIA, tag, por, canal: origem.canal, em: origem.em ?? new Date().toISOString() };
+    const dir = dirDoMonitor(raiz, estadoDir);
+    fs.mkdirSync(dir, { recursive: true });
+    const temp = path.join(dir, `.${ARQUIVO_CADENCIA}.${process.pid}.tmp`);
+    fs.writeFileSync(temp, JSON.stringify(gravada, null, 2) + '\n', { mode: 0o600 });
+    fs.renameSync(temp, path.join(dir, ARQUIVO_CADENCIA));
+    return gravada;
+}
+/** O numero da janela de um instante: minutos locais desde a ancora, divididos pela janela. */
+function janelaDoInstante(def, quando, fuso = (0, horario_1.fusoDoDono)().fuso) {
+    const p = (0, horario_1.partesLocais)(quando, fuso);
+    const localMin = Date.UTC(Number(p.ano), Number(p.mes) - 1, Number(p.dia), Number(p.hora), Number(p.minuto)) / 60000;
+    return Math.floor((localMin - def.ancoraMin) / def.janelaMin);
+}
+/** Quando a proxima janela comeca, em ISO: para dizer ao dono a hora do proximo resumo. */
+function inicioDaProximaJanela(def, quando, fuso = (0, horario_1.fusoDoDono)().fuso) {
+    const atual = janelaDoInstante(def, quando, fuso);
+    let t = Date.parse(quando);
+    // Avanca minuto a minuto no maximo uma janela: simples e sem aritmetica de fuso.
+    for (let i = 0; i <= def.janelaMin; i++) {
+        t += 60_000;
+        if (janelaDoInstante(def, t, fuso) > atual) {
+            const d = new Date(t);
+            d.setUTCSeconds(0, 0);
+            return d.toISOString();
+        }
+    }
+    return new Date(t).toISOString();
+}
+function lerUltimoResumo(raiz, estadoDir) {
+    try {
+        const bruto = JSON.parse(fs.readFileSync(path.join(dirDoMonitor(raiz, estadoDir), ARQUIVO_ULTIMO_RESUMO), 'utf8'));
+        return typeof bruto.em === 'string' && Number.isFinite(Date.parse(bruto.em)) ? bruto.em : null;
+    }
+    catch {
+        return null;
+    }
+}
+function gravarUltimoResumo(raiz, em, estadoDir) {
+    const dir = dirDoMonitor(raiz, estadoDir);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, ARQUIVO_ULTIMO_RESUMO), JSON.stringify({ em }) + '\n', { mode: 0o600 });
+}
+/**
+ * Esta batida do cron pode entregar o status periodico? So quando a janela mudou desde o ultimo
+ * resumo entregue. Pergunta nova ao dono nao passa por aqui: ela sai na hora.
+ */
+function janelaAberta(def, ultimoResumoEm, quando, fuso = (0, horario_1.fusoDoDono)().fuso) {
+    if (!ultimoResumoEm)
+        return true;
+    return janelaDoInstante(def, quando, fuso) > janelaDoInstante(def, ultimoResumoEm, fuso);
+}
+/** A confirmacao que volta ao dono pelo mesmo canal, no fuso dele. */
+function textoDaCadencia(def, quando) {
+    return `Pulse ${def.descricao} (${def.tag}). Pergunta para você continua saindo na hora. ` +
+        `Próximo resumo com novidade a partir de ${(0, horario_1.formatarDataHoraRotulada)(inicioDaProximaJanela(def, quando))}.`;
+}

package/dist/pulse-consentimento.js

@@ -0,0 +1,260 @@
+"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.PRAZO_PADRAO_MIN = exports.ENDERECO_DA_RESPOSTA = exports.ALVO_DO_PULSE = exports.TAMANHO_DO_CODIGO = exports.ALFABETO_DO_CODIGO = exports.CONTRATO_CONSENTIMENTO = void 0;
+exports.arquivoDoConsentimento = arquivoDoConsentimento;
+exports.gerarCodigo = gerarCodigo;
+exports.interpretarResposta = interpretarResposta;
+exports.assinaturaDosCandidatos = assinaturaDosCandidatos;
+exports.lerConsentimento = lerConsentimento;
+exports.consentimentoVigente = consentimentoVigente;
+exports.abrirConsentimento = abrirConsentimento;
+exports.responderConsentimento = responderConsentimento;
+exports.marcarLoteEntregue = marcarLoteEntregue;
+/**
+ * I-41 (D16): o consentimento que separa a camada 1 da camada 2.
+ *
+ * O resumo termina perguntando "Posso te mandar as perguntas agora?". Essa pergunta e um pedido
+ * HITL como qualquer outro, e obedece as mesmas regras: resposta por letra ou palavra curta, sem
+ * identificador longo na mao do humano, e proveniencia provada pelo HMAC do ingresso autenticado.
+ *
+ * O QUE NAO MUDA, e o motivo: `assinaturaDaResposta` e `autenticarResposta` sao chamadas daqui
+ * sem uma linha alterada, e o corpo assinado continua o de sempre. E essa assinatura que impede o
+ * agente consentir no lugar do dono, e ela nao se negocia.
+ *
+ * I-41 (GO-FIX 1, B1): O ENDERECO. O dono digita "P4EJ a" no Telegram, e o gateway que recebe essa
+ * mensagem nao conhece identificador de pedido nenhum. Por isso o ingresso assina o endereco do
+ * pulse (`ALVO_DO_PULSE` na posicao de thread, `ENDERECO_DA_RESPOSTA` na posicao de pedido) junto
+ * com o texto exato que o dono digitou. O codigo esta DENTRO do texto assinado, entao um "sim" a um
+ * resumo nao vale para outro: o codigo precisa bater com o pedido aberto, e a janela de 60
+ * segundos do ingresso fecha a repeticao. Quem traduz o codigo no pedido e o nucleo.
+ *
+ * O consentimento nao e de uma thread: ele e do projeto, porque o resumo atravessa todas. O alvo e
+ * uma constante e nao um nome de thread: ids de thread deste projeto comecam com o abbrev.
+ *
+ * Silencio nao perde nada. Consentimento vencido nao nega e nao apaga: o proximo resumo abre
+ * outro e cita as perguntas guardadas. Os itens vivem no pulse, nao aqui.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const hitl_gates_1 = require("./hitl-gates");
+exports.CONTRATO_CONSENTIMENTO = 'ork.pulse-consent/v1';
+/**
+ * Crockford base32 sem os quatro ambiguos (I, L, O, U). Com letra na frente e ao menos um digito,
+ * quatro caracteres ainda dao mais de 350.000 codigos, e o escopo de unicidade que importa e um: o
+ * consentimento aberto agora. Ambiguo fora do alfabeto importa porque o dono digita isto no
+ * celular, onde 0 e O sao a mesma coisa.
+ */
+exports.ALFABETO_DO_CODIGO = '23456789ABCDEFGHJKMNPQRSTVWXYZ';
+exports.TAMANHO_DO_CODIGO = 4;
+const DIGITOS_DO_CODIGO = '23456789';
+const LETRAS_DO_CODIGO = 'ABCDEFGHJKMNPQRSTVWXYZ';
+/**
+ * I-41 (GO-FIX 1, B1): o endereco do pulse no corpo assinado.
+ *
+ * O ingresso poe `ALVO_DO_PULSE` na posicao de thread e `ENDERECO_DA_RESPOSTA` na posicao de
+ * pedido, e o texto que o dono digitou na posicao de resposta. Nenhum dos dois e nome de thread
+ * ou de pedido: um envelope assinado para uma thread de verdade nao serve aqui, e vice-versa.
+ */
+exports.ALVO_DO_PULSE = 'pulse';
+exports.ENDERECO_DA_RESPOSTA = 'resposta';
+/** Uma hora, a mesma janela do resumo pedido em 20/09. Vencido nao nega: so deixa de valer. */
+exports.PRAZO_PADRAO_MIN = 60;
+const sha = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
+function arquivoDoConsentimento(raiz, estadoDir) {
+    return path.join(estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor'), 'pulse-consentimento.json');
+}
+/**
+ * Codigo novo, uniforme, diferente dos que estiverem em uso agora.
+ *
+ * I-41 (GO-FIX 1): todo codigo comeca por LETRA e tem pelo menos um DIGITO. O ingresso do Telegram
+ * reconhece a resposta ao resumo pela forma "codigo + resposta". Com digito, palavra comum de
+ * quatro letras ("HMMM ok") nunca tem essa forma, e a conversa com o assistente continua indo para
+ * o assistente. Com letra na frente, o codigo nunca e lido como resposta ao lote, que comeca pelo
+ * numero da pergunta: "22A2 a" seria "22a 2a".
+ */
+function gerarCodigo(emUso = []) {
+    const usados = new Set(emUso.map(c => c.toUpperCase()));
+    for (let tentativa = 0; tentativa < 256; tentativa++) {
+        let codigo = LETRAS_DO_CODIGO[(0, node_crypto_1.randomInt)(LETRAS_DO_CODIGO.length)];
+        for (let i = 1; i < exports.TAMANHO_DO_CODIGO; i++)
+            codigo += exports.ALFABETO_DO_CODIGO[(0, node_crypto_1.randomInt)(exports.ALFABETO_DO_CODIGO.length)];
+        if (![...codigo].some(c => DIGITOS_DO_CODIGO.includes(c)))
+            continue;
+        if (!usados.has(codigo))
+            return codigo;
+    }
+    // 810.000 combinacoes contra um punhado em uso: chegar aqui e defeito, nao azar.
+    throw new Error('consentimento do pulse: não foi possível gerar código curto livre');
+}
+/**
+ * O que o dono pode digitar. Letra `a`/`b`, ou palavra curta, com ou sem o codigo na frente,
+ * em qualquer caixa. O que ele NAO precisa digitar e identificador longo.
+ *
+ * Quando o codigo vem escrito, ele precisa bater: um "sim" digitado para o resumo anterior nao
+ * consente com o resumo de agora. Quando nao vem, o pedido aberto e um so e a letra basta.
+ */
+function interpretarResposta(bruto, codigo) {
+    if (typeof bruto !== 'string' || bruto.length > 64)
+        return undefined;
+    const limpo = bruto.trim().toLowerCase().replace(/[.,!]+$/, '');
+    const prefixo = codigo.toLowerCase();
+    const corpo = limpo.startsWith(prefixo) ? limpo.slice(prefixo.length).trim() : limpo;
+    if (limpo !== corpo && corpo === '')
+        return undefined; // só o código, sem escolha, não é resposta
+    if (['a', 's', 'sim', 'pode', 'manda'].includes(corpo))
+        return 'sim';
+    if (['b', 'n', 'nao', 'não', 'agora nao', 'agora não'].includes(corpo))
+        return 'nao';
+    return undefined;
+}
+/**
+ * A assinatura de um conjunto de candidatos: os mesmos gates, a mesma oferta. O pedido aberto nao
+ * entra: ele vence e renasce sem que a pergunta mude, e vencer nao e noticia para o dono.
+ */
+function assinaturaDosCandidatos(candidatos) {
+    return sha(JSON.stringify(candidatos.map(c => [c.thread, c.fase, c.motivo, c.fonte ?? 'gate'])));
+}
+function lerConsentimento(raiz, estadoDir) {
+    const arquivo = arquivoDoConsentimento(raiz, estadoDir);
+    if (!fs.existsSync(arquivo))
+        return undefined;
+    const salvo = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+    if (salvo.versao !== 1 || salvo.pedido?.contrato !== exports.CONTRATO_CONSENTIMENTO) {
+        throw new Error('consentimento do pulse: estado inválido; exige inspeção');
+    }
+    // Estado gravado antes do GO-FIX 1 nao guardava candidatos: sem eles, o sim nao tem o que servir.
+    if (!Array.isArray(salvo.pedido.candidatos)) {
+        salvo.pedido = { ...salvo.pedido, candidatos: [], candidatosSha256: assinaturaDosCandidatos([]) };
+    }
+    return salvo;
+}
+function gravar(raiz, estado, estadoDir) {
+    const arquivo = arquivoDoConsentimento(raiz, estadoDir);
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    const tmp = arquivo + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(estado) + '\n', { mode: 0o600 });
+    fs.renameSync(tmp, arquivo);
+}
+/** O pedido que ainda vale agora: aberto, dentro do prazo e sem resposta gravada. */
+function consentimentoVigente(raiz, quando, estadoDir) {
+    const estado = lerConsentimento(raiz, estadoDir);
+    if (!estado || estado.respondido)
+        return undefined;
+    return Date.parse(quando) < Date.parse(estado.pedido.prazo) ? estado.pedido : undefined;
+}
+/**
+ * Abre o pedido que acompanha um resumo. Um pedido vigente NAO e substituido: trocar o codigo
+ * debaixo de quem esta digitando e o defeito que fez a mesma pergunta sair com tres
+ * identificadores diferentes entre 16/09 e 20/09.
+ */
+function abrirConsentimento(raiz, entrada) {
+    const candidatos = [...(entrada.candidatos ?? [])];
+    const candidatosSha256 = assinaturaDosCandidatos(candidatos);
+    const vigente = consentimentoVigente(raiz, entrada.quando, entrada.estadoDir);
+    if (vigente && vigente.resumoSha256 === entrada.resumoSha256 && vigente.candidatosSha256 === candidatosSha256)
+        return vigente;
+    const anterior = lerConsentimento(raiz, entrada.estadoDir)?.pedido.codigo;
+    const prazoMin = entrada.prazoMin ?? exports.PRAZO_PADRAO_MIN;
+    const pedido = {
+        contrato: exports.CONTRATO_CONSENTIMENTO, id: (0, node_crypto_1.randomUUID)(),
+        // O codigo novo nunca repete o anterior: um "sim" atrasado ao resumo velho nao vale para o novo.
+        codigo: gerarCodigo(anterior ? [anterior] : []),
+        criadoEm: entrada.quando,
+        prazo: new Date(Date.parse(entrada.quando) + prazoMin * 60000).toISOString(),
+        acumuladas: candidatos.length, resumoSha256: entrada.resumoSha256, candidatos, candidatosSha256,
+    };
+    gravar(raiz, { versao: 1, pedido }, entrada.estadoDir);
+    return pedido;
+}
+/**
+ * Recebe a resposta do dono pelo codigo curto.
+ *
+ * A ordem importa e e a mesma do gate: primeiro proveniencia, depois conteudo. Um envelope sem
+ * assinatura valida nunca chega a ser interpretado como "sim", e por isso texto malformado de
+ * origem nao autenticada nao consegue liberar lote nenhum. O envelope e o que o ingresso assinou
+ * para o endereco do pulse, com o texto que o dono digitou ("P4EJ a").
+ *
+ * Repetir a MESMA resposta devolve o que ja foi decidido, inclusive por outra mensagem: o dono que
+ * nao viu o lote chegar manda "P4EJ a" de novo e recebe o mesmo lote, nunca um lote novo. Mudar
+ * de ideia sobre o mesmo resumo e recusado com o que ja vale.
+ */
+function responderConsentimento(raiz, entrada) {
+    const quando = entrada.quando ?? new Date().toISOString();
+    const estado = lerConsentimento(raiz, entrada.estadoDir);
+    if (!estado)
+        throw new Error('consentimento do pulse: não há pedido aberto');
+    const { pedido } = estado;
+    if (pedido.codigo.toUpperCase() !== String(entrada.codigo).trim().toUpperCase()) {
+        throw new Error('consentimento do pulse: código não confere com o pedido aberto');
+    }
+    // Proveniencia primeiro, pelo caminho de sempre, no endereco do pulse.
+    (0, hitl_gates_1.autenticarResposta)(exports.ALVO_DO_PULSE, exports.ENDERECO_DA_RESPOSTA, entrada.envelope, entrada.envelope.recebidoEm);
+    (0, hitl_gates_1.autenticarResposta)(exports.ALVO_DO_PULSE, exports.ENDERECO_DA_RESPOSTA, entrada.envelope, quando);
+    const resposta = interpretarResposta(entrada.envelope.resposta, pedido.codigo);
+    const recibo = sha(entrada.envelope.prova);
+    if (estado.respondido) {
+        // Uso unico por significado: a mesma resposta do mesmo dono devolve o que ja foi decidido.
+        if (resposta !== estado.respondido.resposta || estado.respondido.por !== entrada.envelope.por) {
+            throw new Error('consentimento do pulse: já respondido; resposta divergente recusada');
+        }
+        return { resposta: estado.respondido.resposta, repetida: true, pedido, respondido: estado.respondido };
+    }
+    if (Date.parse(quando) >= Date.parse(pedido.prazo)) {
+        throw new Error('consentimento do pulse: pedido vencido; nenhuma autorização concedida');
+    }
+    if (!resposta)
+        throw new Error('consentimento do pulse: responda com a (sim) ou b (agora não)');
+    const respondido = {
+        resposta, respondidoEm: quando, mensagem: entrada.envelope.mensagem, por: entrada.envelope.por, recibo,
+    };
+    gravar(raiz, { ...estado, respondido }, entrada.estadoDir);
+    return { resposta, repetida: false, pedido, respondido };
+}
+/**
+ * Marca o lote consentido como entregue, com os numeros que ele levou. Sem isto, um sim viraria
+ * autorizacao permanente e a cada resposta sairia um lote novo, que e a inundacao voltando por
+ * outra porta. Com os numeros, repetir o sim devolve o MESMO lote.
+ */
+function marcarLoteEntregue(raiz, quando, estadoDir, numeros) {
+    const estado = lerConsentimento(raiz, estadoDir);
+    if (!estado?.respondido || estado.respondido.resposta !== 'sim')
+        throw new Error('consentimento do pulse: não há sim para servir');
+    if (estado.respondido.loteEntregueEm)
+        throw new Error('consentimento do pulse: este sim já serviu um lote');
+    gravar(raiz, { ...estado, respondido: { ...estado.respondido, loteEntregueEm: quando, numeros: [...numeros] } }, estadoDir);
+}