@orkastery/cli 0.5.0 → 0.5.3

package/dist/prova-ativacao.js

@@ -0,0 +1,414 @@
+"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.ENTRADAS = exports.HOSTS_DA_PROVA = void 0;
+exports.transcriptDoClaude = transcriptDoClaude;
+exports.transcriptDoOpenclaw = transcriptDoOpenclaw;
+exports.transcriptDoCodex = transcriptDoCodex;
+exports.extrairSnapshot = extrairSnapshot;
+exports.conferirProva = conferirProva;
+exports.redigir = redigir;
+exports.redigirObjeto = redigirObjeto;
+/**
+ * RM-032: conferência da prova de ativação por host, sem host.
+ *
+ * O roteiro `core/scripts/prova-ativacao.cjs` abre uma sessão nova e não interativa no host
+ * (Claude Code, OpenClaw ou Codex), diz `orkastery maestro` e entrega aqui o transcript. Esta
+ * conferência olha só o que é determinístico: qual ferramenta o modelo chamou, o resultado que
+ * ela devolveu (contra o contrato da entrada) e o projeto lido. Da resposta final em texto
+ * livre, exige apenas que cite o projeto e não repita o incidente de 29/09 ("roadmap vazio").
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const maestro_contract_1 = require("./maestro-contract");
+exports.HOSTS_DA_PROVA = ['claude-code', 'openclaw', 'codex'];
+/**
+ * As entradas da frase em cada host. No Claude, a tool MCP do servidor `orkastery` fixado no
+ * projeto (MAESTRO_HOST_SURFACES em hosts.ts). No OpenClaw 0.5.0 (RM-054, fatia 2), a frase sem
+ * projeto vai a `ork_network_roadmap`, a única tool da extensão no perfil `coding`; com projeto
+ * nomeado, a `ork_maestro`. No Codex (B11), a tool `ork_maestro` do servidor `orkastery` que o
+ * `ork mcp install --host codex` grava no projeto; o nome segue o padrão `mcp__<servidor>__<tool>`.
+ * `ork maestro` pelo shell do host é desvio: o CLI resolve o projeto pelo diretório atual, a classe
+ * de erro do incidente.
+ */
+exports.ENTRADAS = {
+    'claude-code': [{ ferramenta: 'mcp__orkastery__ork_maestro', contrato: 'maestro' }],
+    openclaw: [{ ferramenta: 'ork_network_roadmap', contrato: 'rede' }, { ferramenta: 'ork_maestro', contrato: 'maestro' }],
+    codex: [{ ferramenta: 'mcp__orkastery__ork_maestro', contrato: 'maestro' }],
+};
+const SHELL_DO_HOST = { 'claude-code': 'Bash', openclaw: 'exec', codex: 'command_execution' };
+// B11: o shell do Codex chega embrulhado (`bash -lc 'ork maestro'`), então aspas também abrem o comando.
+// Suspeitas da revisão de 03/10: o mesmo CLI roda também pelo caminho do binário (`$(which ork)`), pelo
+// node (`core/dist/index.js`), pelo npx (`@orkastery/cli`) e com o projeto entre aspas. É desvio a
+// invocação do ork cujo subcomando, depois só de opções (com valor, até entre aspas), é `maestro`;
+// `maestro` dentro do argumento de outro subcomando não é.
+const INVOCACAO_DO_ORK = String.raw `(?:(?:^|[^\w.@-])ork|@orkastery\/cli(?:@[\w.-]+)?|\bdist\/index\.js)(?![\w.-])[)\x60]?`;
+const VALOR = String.raw `(?:"[^"]*"|'[^']*'|[^\s"'-][^\s"']*)`;
+const OPCOES = String.raw `(?:\s+-[\w-]*(?:=(?:"[^"]*"|'[^']*'|[^\s"']+))?(?:\s+${VALOR})?)*`;
+const ORK_MAESTRO_NO_SHELL = new RegExp(String.raw `${INVOCACAO_DO_ORK}${OPCOES}\s+maestro(?![\w.-])`);
+function linhasJson(texto) {
+    const eventos = [];
+    for (const linha of texto.split('\n')) {
+        const limpa = linha.trim();
+        if (!limpa.startsWith('{'))
+            continue;
+        try {
+            eventos.push(JSON.parse(limpa));
+        }
+        catch { /* linha de log do host, não evento */ }
+    }
+    return eventos;
+}
+function textoDoConteudo(conteudo) {
+    if (typeof conteudo === 'string')
+        return conteudo;
+    if (!Array.isArray(conteudo))
+        return null;
+    const partes = conteudo.filter((c) => !!c && typeof c === 'object' && c.type === 'text' && typeof c.text === 'string');
+    return partes.length ? partes.map(p => p.text).join('\n') : null;
+}
+function classificar(host, ferramenta, argumentos) {
+    const entrada = exports.ENTRADAS[host].find(e => e.ferramenta === ferramenta);
+    if (entrada)
+        return { via: 'entrada', contrato: entrada.contrato };
+    const comando = argumentos?.command;
+    if (ferramenta === SHELL_DO_HOST[host] && typeof comando === 'string' && ORK_MAESTRO_NO_SHELL.test(comando))
+        return { via: 'shell', contrato: null };
+    return null;
+}
+/** Transcript `claude -p --output-format stream-json --verbose`. */
+function transcriptDoClaude(streamJson) {
+    const eventos = linhasJson(streamJson);
+    let ferramentasExpostas = null;
+    let respostaFinal = null;
+    const pedidas = new Map();
+    const chamadas = [];
+    for (const e of eventos) {
+        if (e.type === 'system' && e.subtype === 'init' && Array.isArray(e.tools))
+            ferramentasExpostas = e.tools.filter((t) => typeof t === 'string');
+        const mensagem = e.message;
+        const blocos = Array.isArray(mensagem?.content) ? mensagem.content : [];
+        if (e.type === 'assistant') {
+            for (const b of blocos) {
+                if (b?.type !== 'tool_use' || typeof b.name !== 'string' || typeof b.id !== 'string')
+                    continue;
+                const tipo = classificar('claude-code', b.name, b.input);
+                if (!tipo)
+                    continue;
+                const chamada = { ferramenta: b.name, ...tipo, argumentos: b.input ?? null, resultado: null, erro: false };
+                pedidas.set(b.id, chamada);
+                chamadas.push(chamada);
+            }
+        }
+        else if (e.type === 'user') {
+            for (const b of blocos) {
+                if (b?.type !== 'tool_result' || typeof b.tool_use_id !== 'string')
+                    continue;
+                const chamada = pedidas.get(b.tool_use_id);
+                if (!chamada)
+                    continue;
+                chamada.resultado = textoDoConteudo(b.content);
+                chamada.erro = b.is_error === true;
+            }
+        }
+        else if (e.type === 'result' && typeof e.result === 'string')
+            respostaFinal = e.result;
+    }
+    return { ferramentasExpostas, chamadas, respostaFinal };
+}
+/**
+ * Trajetória do OpenClaw (`openclaw sessions export-trajectory`, `events.jsonl`): eventos
+ * `tool.call`/`tool.result` da origem `runtime`. As ferramentas expostas e a resposta final vêm
+ * do `openclaw agent --json` (`meta.systemPromptReport.tools.entries`, `payloads[].text`).
+ */
+function transcriptDoOpenclaw(eventsJsonl, agenteJson) {
+    const pedidas = new Map();
+    const chamadas = [];
+    for (const e of linhasJson(eventsJsonl)) {
+        if (e.source !== 'runtime')
+            continue;
+        const d = (e.data ?? {});
+        if (typeof d.toolCallId !== 'string' || typeof d.name !== 'string')
+            continue;
+        if (e.type === 'tool.call') {
+            const tipo = classificar('openclaw', d.name, d.args);
+            if (!tipo)
+                continue;
+            const chamada = { ferramenta: d.name, ...tipo, argumentos: d.args ?? null, resultado: null, erro: false };
+            pedidas.set(d.toolCallId, chamada);
+            chamadas.push(chamada);
+        }
+        else if (e.type === 'tool.result') {
+            const chamada = pedidas.get(d.toolCallId);
+            if (!chamada)
+                continue;
+            chamada.resultado = textoDoConteudo(d.result?.content);
+            chamada.erro = d.success !== true;
+        }
+    }
+    const agente = (agenteJson ?? {});
+    const entradas = agente.meta?.systemPromptReport?.tools?.entries;
+    const ferramentasExpostas = Array.isArray(entradas) ? entradas.map(t => t?.name).filter((n) => typeof n === 'string') : null;
+    const textos = (agente.payloads ?? []).map(p => p?.text).filter((t) => typeof t === 'string');
+    return { ferramentasExpostas, chamadas, respostaFinal: textos.length ? textos.join('\n') : null };
+}
+/**
+ * Eventos do `codex exec --json` (B11): `item.started`/`item.completed` com `mcp_tool_call` (servidor,
+ * tool, argumentos, resultado, erro), `command_execution` (o shell do host) e `agent_message` (a
+ * resposta). O `codex exec` não lista as ferramentas expostas ao modelo: quem chama passa as do
+ * `tools/list` do mesmo servidor MCP que a sessão recebeu, já com o nome `mcp__<servidor>__<tool>`.
+ */
+function transcriptDoCodex(eventosJsonl, ferramentasExpostas) {
+    const porItem = new Map();
+    const chamadas = [];
+    const mensagens = [];
+    for (const e of linhasJson(eventosJsonl)) {
+        if (e.type !== 'item.started' && e.type !== 'item.completed')
+            continue;
+        const item = (e.item ?? {});
+        const id = typeof item.id === 'string' ? item.id : null;
+        if (item.type === 'agent_message') {
+            if (e.type === 'item.completed' && typeof item.text === 'string')
+                mensagens.push(item.text);
+            continue;
+        }
+        let ferramenta, argumentos, resultado = null, erro = false;
+        if (item.type === 'mcp_tool_call' && typeof item.server === 'string' && typeof item.tool === 'string') {
+            ferramenta = `mcp__${item.server}__${item.tool}`;
+            argumentos = item.arguments ?? null;
+            const r = item.result;
+            resultado = typeof r === 'string' ? r : textoDoConteudo(r?.content);
+            const falha = item.error;
+            erro = !!falha || item.status === 'failed';
+            if (erro && resultado === null)
+                resultado = typeof falha === 'string' ? falha : typeof falha?.message === 'string' ? falha.message : 'falhou';
+        }
+        else if (item.type === 'command_execution' && typeof item.command === 'string') {
+            ferramenta = 'command_execution';
+            argumentos = { command: item.command };
+            resultado = typeof item.aggregated_output === 'string' ? item.aggregated_output : null;
+            erro = item.status === 'failed' || (typeof item.exit_code === 'number' && item.exit_code !== 0);
+        }
+        else
+            continue;
+        const tipo = classificar('codex', ferramenta, argumentos);
+        if (!tipo)
+            continue;
+        const anterior = id ? porItem.get(id) : undefined;
+        if (anterior) {
+            // `item.completed` do mesmo item fecha a chamada aberta no `item.started`.
+            if (e.type === 'item.completed')
+                Object.assign(anterior, { argumentos, resultado, erro });
+            continue;
+        }
+        const chamada = { ferramenta, ...tipo, argumentos, resultado: e.type === 'item.completed' ? resultado : null,
+            erro: e.type === 'item.completed' ? erro : false };
+        if (id)
+            porItem.set(id, chamada);
+        chamadas.push(chamada);
+    }
+    return { ferramentasExpostas, chamadas, respostaFinal: mensagens.length ? mensagens.at(-1) : null };
+}
+/** O primeiro objeto `ork.maestro-snapshot/v1` do texto (o host pode juntar stderr ao stdout). */
+function extrairSnapshot(texto) {
+    const inicio = texto.indexOf('{"schema":"ork.maestro-snapshot/v1"');
+    if (inicio < 0)
+        return null;
+    let profundidade = 0, emTexto = false, escape = false;
+    for (let i = inicio; i < texto.length; i++) {
+        const c = texto[i];
+        if (emTexto) {
+            if (escape)
+                escape = false;
+            else if (c === '\\')
+                escape = true;
+            else if (c === '"')
+                emTexto = false;
+        }
+        else if (c === '"')
+            emTexto = true;
+        else if (c === '{')
+            profundidade++;
+        else if (c === '}' && --profundidade === 0) {
+            try {
+                return JSON.parse(texto.slice(inicio, i + 1));
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+function expandirHome(raiz, home) {
+    return raiz === '~' ? home : raiz.startsWith('~/') ? path.join(home, raiz.slice(2)) : raiz;
+}
+const ROADMAP_VAZIO = /\broadmap\b:?((?:\s+[^\s.!?:;,]+){0,4}?)\s+(vazio|empty)\b/giu;
+const NEGACAO = /(^|[^\p{L}])(n[ãa]o|nunca|jamais|not|never|isn't|doesn't|nem)([^\p{L}]|$)/iu;
+/**
+ * A frase que conclui "roadmap vazio". A negação só conta quando governa a conclusão: dentro do
+ * trecho ("the roadmap is not empty") ou nas até seis palavras antes dele, sem atravessar
+ * pontuação ("zero threads não quer dizer roadmap vazio"). "O roadmap está vazio e não há
+ * threads" e "Não há itens: o roadmap está vazio" concluem.
+ */
+function concluiRoadmapVazio(texto) {
+    for (const m of texto.matchAll(ROADMAP_VAZIO)) {
+        const antes = texto.slice(0, m.index).split(/[.!?:;,\n]/).pop().trim().split(/\s+/).slice(-6).join(' ');
+        if (!NEGACAO.test(antes) && !NEGACAO.test(m[1]))
+            return `${antes} ${m[0]}`.trim();
+    }
+    return null;
+}
+const canonica = (p) => { try {
+    return fs.realpathSync(p);
+}
+catch {
+    return path.resolve(p);
+} };
+/** Nome inteiro, não pedaço de palavra: a abreviação `pav` não casa com "pavimento". */
+const nomeia = (texto, nome) => new RegExp(`(^|[^\\p{L}\\p{N}_-])${nome.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^\\p{L}\\p{N}_-]|$)`, 'iu').test(texto);
+/**
+ * O texto de `ork network roadmap` (`textoDoPanoramaDaRede`): a primeira linha diz de onde foi
+ * lido, a segunda quais projetos foram consultados (`<nome> (clone em <raiz>)`) e o bloco
+ * "Não consultado:" o que ficou de fora.
+ */
+function lerPanoramaDaRede(texto) {
+    const linhas = texto.split('\n');
+    const i = linhas.findIndex(l => /^Panorama da rede lido de /.test(l));
+    if (i < 0 || !/^Consultado: /.test(linhas[i + 1] ?? '') || linhas[i + 2] !== 'Não consultado:')
+        return null;
+    const naoConsultado = [];
+    for (const l of linhas.slice(i + 3)) {
+        if (!l.startsWith('• '))
+            break;
+        naoConsultado.push(l.slice(2));
+    }
+    return { cabecalho: linhas[i], consultado: linhas[i + 1], naoConsultado };
+}
+function conferirProva(host, t, esperado) {
+    const conferencias = [];
+    const conferir = (id, ok, detalhe) => { conferencias.push({ id, ok, detalhe }); return ok; };
+    const nomes = exports.ENTRADAS[host].map(e => e.ferramenta);
+    const expostas = nomes.filter(n => t.ferramentasExpostas?.includes(n));
+    conferir('entrada.exposta', expostas.length > 0, t.ferramentasExpostas === null ? 'o transcript não lista as ferramentas expostas'
+        : expostas.length ? `${expostas.join(', ')} exposta(s) ao modelo`
+            : `${nomes.join(' e ')} ausente(s) entre ${t.ferramentasExpostas.length} ferramentas expostas`);
+    // A última chamada contratada com resultado é a que vale (uma nova tentativa depois de erro não
+    // reprova); qualquer `ork maestro` pelo shell reprova, mesmo ao lado da chamada contratada.
+    const contratadas = t.chamadas.filter(c => c.via === 'entrada');
+    const contratada = [...contratadas].reverse().find(c => c.resultado !== null && !c.erro) ?? contratadas.at(-1);
+    const desvio = t.chamadas.find(c => c.via === 'shell');
+    const comando = desvio && JSON.stringify(desvio.argumentos?.command);
+    conferir('entrada.chamada', !!contratada && !desvio, contratada && desvio ? `${contratada.ferramenta} chamada, mas também desvio: ${desvio.ferramenta} ${comando}`
+        : contratada ? `${contratada.ferramenta} chamada`
+            : desvio ? `desvio: ${desvio.ferramenta} ${comando} em vez de ${nomes.join(' ou ')}`
+                : `${nomes.join(' ou ')} não foi chamada`);
+    let snapshot = null;
+    let rede = null;
+    if (contratada && conferir('resultado.sem-erro', contratada.resultado !== null && !contratada.erro, contratada.resultado === null ? 'a chamada não teve resultado' : contratada.erro ? `erro: ${contratada.resultado.slice(0, 300)}` : 'resultado sem erro')) {
+        if (contratada.contrato === 'maestro') {
+            try {
+                snapshot = (0, maestro_contract_1.validateMaestroSnapshot)(extrairSnapshot(contratada.resultado));
+                conferir('resultado.contrato', true, `${snapshot.schema} validado`);
+            }
+            catch (e) {
+                conferir('resultado.contrato', false, `fora do contrato: ${e.message.slice(0, 300)}`);
+            }
+        }
+        else {
+            rede = lerPanoramaDaRede(contratada.resultado);
+            conferir('resultado.contrato', rede !== null, rede ? 'texto do ork.network-roadmap/v1: cabeçalho, Consultado e Não consultado'
+                : 'fora do contrato: sem o cabeçalho "Panorama da rede lido de", "Consultado:" e "Não consultado:"');
+        }
+    }
+    if (snapshot) {
+        const p = snapshot.project;
+        const exibida = p.root === undefined || p.root.includes('[caminho privado]') ? null : canonica(expandirHome(p.root, esperado.home));
+        const mesmaCopia = p.fingerprint === esperado.projeto.fingerprint && (exibida === null || exibida === canonica(esperado.projeto.raiz));
+        conferir('resultado.projeto', p.name === esperado.projeto.nome && mesmaCopia, `leu ${p.name} (${p.origin}) em ${p.root ?? 'raiz não exibida'}, impressão ${p.fingerprint.slice(0, 12)}; ` +
+            `esperado ${esperado.projeto.nome}, impressão ${esperado.projeto.fingerprint.slice(0, 12)}`);
+        const lacunas = snapshot.notConsulted ?? [];
+        conferir('resultado.nao-consultado', lacunas.length > 0, lacunas.length ? `declara o que não leu: ${lacunas.length} item(ns)` : 'notConsulted ausente: zero threads pode virar "roadmap vazio"');
+    }
+    if (rede) {
+        // "Consultado: a (clone em X); b (clone em Y)": vale o projeto esperado na raiz esperada.
+        const lidos = [...rede.consultado.replace(/^Consultado: /, '').matchAll(/(?:^|; )(.+?) \(clone em ([^)]+)\)/g)];
+        const leu = lidos.some(([, nome, raiz]) => nome === esperado.projeto.nome &&
+            canonica(expandirHome(raiz, esperado.home)) === canonica(esperado.projeto.raiz));
+        conferir('resultado.projeto', leu, `${rede.consultado.slice(0, 300)}; esperado ${esperado.projeto.nome} (clone em ${esperado.projeto.raiz})`);
+        conferir('resultado.nao-consultado', rede.naoConsultado.length > 0, rede.naoConsultado.length ? `declara o que não leu: ${rede.naoConsultado.length} item(ns)` : 'sem o bloco do que não foi consultado');
+    }
+    const resposta = t.respostaFinal ?? '';
+    const citaProjeto = [esperado.projeto.nome, esperado.projeto.id].some(n => nomeia(resposta, n));
+    conferir('resposta.cita-projeto', citaProjeto, t.respostaFinal === null ? 'sem resposta final' : citaProjeto ? 'a resposta nomeia o projeto lido' : 'a resposta não nomeia o projeto lido');
+    const vazio = concluiRoadmapVazio(resposta);
+    conferir('resposta.sem-roadmap-vazio', vazio === null, vazio ? `a resposta conclui "roadmap vazio" a partir do panorama (incidente de 29/09): ${vazio.slice(0, 200)}` : 'sem concluir "roadmap vazio" a partir do panorama');
+    return {
+        ok: conferencias.every(c => c.ok),
+        conferencias,
+        snapshot: snapshot && {
+            schema: snapshot.schema, projeto: snapshot.project,
+            secoes: Object.fromEntries(Object.entries(snapshot.sections).map(([nome, s]) => [nome, s.state])),
+            notConsulted: snapshot.notConsulted ?? [],
+        },
+        rede,
+    };
+}
+/**
+ * Redação antes de qualquer gravação: o recibo vai ao repositório. Cobre tokens com prefixo
+ * conhecido, `Bearer`/`Basic`, variáveis de ambiente com nome de segredo e valores de chaves JSON
+ * com nome de segredo. Para objetos, use `redigirObjeto`, que aplica a regra a cada texto antes
+ * da serialização (JSON dentro de stdout escaparia depois dela).
+ */
+const CHAVE_DE_SEGREDO = /token|secret|password|passwd|api[_-]?key|apikey|credential|authorization|cookie/i;
+function redigir(texto) {
+    return texto
+        .replace(/\b(sk-ant-[A-Za-z0-9_-]+|sk-or-[A-Za-z0-9_-]+|sk-[A-Za-z0-9_-]{16,}|[sr]k_live_[A-Za-z0-9]{10,}|AIza[0-9A-Za-z_-]{20,})/g, '[REDIGIDO]')
+        .replace(/\b(gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|glpat-[A-Za-z0-9_-]{16,}|xox[abprs]-[A-Za-z0-9-]{10,})/g, '[REDIGIDO]')
+        .replace(/\b(Bearer|Basic)(\s+)[A-Za-z0-9._~+/-]{8,}=*/gi, '$1$2[REDIGIDO]')
+        // O valor para em aspas, barra invertida e espaço: aplicada a JSON, a regra não come o fecho.
+        .replace(/\b([A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)[A-Z0-9_]*\s*=\s*)(?!\d+\b)("[^"\\]*"|'[^'\\]*'|[^\s"'\\]+)/g, '$1[REDIGIDO]')
+        .replace(/("[^"]*(?:token|secret|password|passwd|api[_-]?key|apikey|credential|authorization|cookie)[^"]*"\s*:\s*)"(?:[^"\\]|\\.)*"/gi, '$1"[REDIGIDO]"');
+}
+function redigirObjeto(valor) {
+    if (typeof valor === 'string')
+        return redigir(valor);
+    if (Array.isArray(valor))
+        return valor.map(v => redigirObjeto(v));
+    if (valor && typeof valor === 'object') {
+        return Object.fromEntries(Object.entries(valor).map(([k, v]) => [k, typeof v === 'string' && CHAVE_DE_SEGREDO.test(k) ? '[REDIGIDO]' : redigirObjeto(v)]));
+    }
+    return valor;
+}

package/dist/pulse-delivery.js

@@ -33,11 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.adquirirLockMonitor = void 0;
+exports.RETEM_PARADO_MS = exports.adquirirLockMonitor = void 0;
 exports.assinaturaPulse = assinaturaPulse;
 exports.assinaturaDoResumo = assinaturaDoResumo;
 exports.mensagemPulse = mensagemPulse;
 exports.varrerPulse = varrerPulse;
+exports.varrerEDepoisPublicarNaRede = varrerEDepoisPublicarNaRede;
 exports.enviarPayloadHost = enviarPayloadHost;
 const manifest_1 = require("./manifest");
 const write_activation_1 = require("./write-activation");
@@ -59,10 +60,14 @@ const hitl_contract_1 = require("./hitl-contract");
 const monitor_lock_1 = require("./monitor-lock");
 const fabrica_estado_1 = require("./fabrica-estado");
 const maquina_1 = require("./maquina");
+const rede_1 = require("./rede");
+const rede_adesao_1 = require("./rede-adesao");
 const pulse_cadencia_1 = require("./pulse-cadencia");
 // O lock dos monitores mudou de modulo (I-41, GO-FIX 1); quem o importava daqui continua importando.
 var monitor_lock_2 = require("./monitor-lock");
 Object.defineProperty(exports, "adquirirLockMonitor", { enumerable: true, get: function () { return monitor_lock_2.adquirirLockMonitor; } });
+/** RM-037 (fatia 4): por quanto tempo a parada ja informada continua sabida depois de sumir de uma batida. */
+exports.RETEM_PARADO_MS = 6 * 60 * 60 * 1000;
 /**
  * I-41 (D9): a assinatura de deduplicacao NAO inclui `apresentacao`.
  *
@@ -183,9 +188,24 @@ function varrerPulse(opcoes) {
         const esperasFora = outras.flatMap(m => m.esperando.map(e => `maquina:${m.maquina}:${e.thread}:${e.fase}`));
         for (const k of esperasFora)
             presentes.add(k);
-        vistas = Object.fromEntries(Object.entries(vistas).filter(([id]) => presentes.has(id)));
+        // RM-037 (fatia 4, D7): o trabalho parado no condutor e noticia uma vez por thread e caso, como a
+        // decisao informada: sai na janela da cadencia do dono e nunca abre pedido.
+        const parados = pulse.paradoNoCondutor ?? [];
+        const chaveDoParado = (p) => `parado:${p.thread}:${p.caso}`;
+        for (const p of parados)
+            presentes.add(chaveDoParado(p));
+        // A parada que some por uma batida (gh que falhou, um `ork verify` do condutor) e volta nao e noticia
+        // nova: a marca fica guardada por `RETEM_PARADO_MS` depois da ultima vez que a parada apareceu.
+        const guardada = (id, valor) => id.startsWith('parado:') &&
+            Date.parse(quando) - Number(valor.split('|')[1]) < exports.RETEM_PARADO_MS;
+        vistas = Object.fromEntries(Object.entries(vistas).filter(([id, valor]) => presentes.has(id) || guardada(id, valor)));
         const esperaNovaFora = esperasFora.some(k => vistas[k] === undefined);
         const decisoesNovas = decisoes.filter(d => vistas[chaveDaDecisao(d.id)] === undefined);
+        const paradosNovos = parados.filter(p => vistas[chaveDoParado(p)] === undefined);
+        // A marca guarda o instante em milissegundos: e dado de maquina, nao texto para o dono.
+        for (const p of parados)
+            if (vistas[chaveDoParado(p)] !== undefined)
+                vistas[chaveDoParado(p)] = `informada|${Date.parse(quando)}`;
         // I-41 (GO-FIX 1): a thread que ja recebeu a pergunta e ainda nao respondeu nao e noticia. A
         // mudanca no item dela (o pedido que o sim do dono abriu) e obra nossa, e avisar sobre ela seria
         // mandar ao dono um resumo sobre a pergunta que ele acabou de receber.
@@ -205,7 +225,8 @@ function varrerPulse(opcoes) {
                     !config.argumentos.every(a => typeof a === 'string') || !config.argumentos.some(a => a.includes('{{mensagem}}'))) {
                     throw new Error('transporte requer executavel e argumentos com {{mensagem}}');
                 }
-                const r = (0, node_child_process_1.spawnSync)(config.executavel, config.argumentos.map(a => a.replaceAll('{{mensagem}}', mensagem)), { cwd: raiz, encoding: 'utf8', input: mensagem, timeout: 30000, maxBuffer: 1024 * 1024 });
+                // A mensagem entra como texto: `$&` e `$'` nela nao sao padrao de substituicao (CHECK da RM-037, fatia 4).
+                const r = (0, node_child_process_1.spawnSync)(config.executavel, config.argumentos.map(a => a.replaceAll('{{mensagem}}', () => mensagem)), { cwd: raiz, encoding: 'utf8', input: mensagem, timeout: 30000, maxBuffer: 1024 * 1024 });
                 entregue = r.status === 0;
             }
             if (!entregue)
@@ -229,12 +250,15 @@ function varrerPulse(opcoes) {
         // I-50: pergunta nova sai na hora; o resto (status, decisoes informadas) espera a janela da
         // cadencia do dono, e a novidade que esperou continua nao vista ate sair.
         const noPrazo = !opcoes.comCadencia || (0, pulse_cadencia_1.janelaAberta)(cadencia, (0, pulse_cadencia_1.lerUltimoResumo)(opcoes.raiz, dir), quando);
-        const adiada = !conjuntoNovo && !esperaNovaFora && (novas > 0 || decisoesNovas.length > 0) && !noPrazo;
-        if (conjuntoNovo || esperaNovaFora || (noPrazo && (novas > 0 || decisoesNovas.length > 0))) {
+        const informacaoNova = novas > 0 || decisoesNovas.length > 0 || paradosNovos.length > 0;
+        const adiada = !conjuntoNovo && !esperaNovaFora && informacaoNova && !noPrazo;
+        if (conjuntoNovo || esperaNovaFora || (noPrazo && informacaoNova)) {
             const guardadas = anterior ? fila.candidatos.filter(c => anterior.candidatos.some(a => a.thread === c.thread)).length : 0;
             const resumo = (0, hitl_resumo_1.resumirHitl)(itens, { quando, janelaMin, prontas: fila.candidatos.length, acumuladas: guardadas,
                 consertos: fila.consertos, atoDoItem: i => fila.atos.get(`${i.thread}|${i.fase}`),
-                decisoes: decisoesNovas, acimaDoLimiar: pulse.acimaDoLimiar ?? [], outrasMaquinas: outras });
+                decisoes: decisoesNovas, acimaDoLimiar: pulse.acimaDoLimiar ?? [], outrasMaquinas: outras, paradosNoCondutor: parados,
+                // RM-057 (fatia 3): a linha so acompanha o resumo que ja sai; nao e novidade nem fura a cadencia.
+                ...(pulse.hitlDeConducao ? { hitlDeConducao: pulse.hitlDeConducao } : {}) });
             // Pedir licenca para mandar zero perguntas era o defeito: sem pergunta, nao ha codigo.
             // I-50: cadencia curta nao encurta o prazo do dono para responder ao resumo (minimo de 60 min).
             const consentimento = fila.candidatos.length ? (0, monitor_lock_1.comLockDaConversa)(dir, () => (0, pulse_consentimento_1.abrirConsentimento)(raiz, { quando,
@@ -252,6 +276,8 @@ function varrerPulse(opcoes) {
                 vistas[chaveDaDecisao(d.id)] = 'informada';
             for (const k of esperasFora)
                 vistas[k] = 'informada';
+            for (const p of parados)
+                vistas[chaveDoParado(p)] = `informada|${Date.parse(quando)}`;
             (0, pulse_cadencia_1.gravarUltimoResumo)(opcoes.raiz, quando, dir);
         }
         gravarCache(cache, vistas);
@@ -266,6 +292,22 @@ function varrerPulse(opcoes) {
         trava.liberar();
     }
 }
+/**
+ * RM-053: a entrega ao dono vem primeiro, e a rede depois, mesmo quando a varredura falha. M4 do
+ * CHECK 1: antes da entrega, uma forja lenta atrasava o HITL em minutos. S13 da revisao 2: sem o
+ * `finally`, uma excecao na varredura suprimia tambem a batida da rede.
+ */
+function varrerEDepoisPublicarNaRede(varrer, publicar) {
+    try {
+        return varrer();
+    }
+    finally {
+        try {
+            publicar();
+        }
+        catch { /* a rede registra a propria falha no rede.log */ }
+    }
+}
 if (require.main === module) {
     try {
         const raiz = process.argv[2] ?? process.cwd();
@@ -296,7 +338,18 @@ if (require.main === module) {
         }
         const outrasMaquinas = compartilhada
             ? () => (0, fabrica_estado_1.resumoDasOutrasMaquinas)((0, fabrica_estado_1.lerFabrica)(carregado.raiz, { remoto, semRemoto: true }), (0, maquina_1.nomeDaMaquina)()) : undefined;
-        const r = varrerPulse({ raiz, escopo, comCadencia: true, outrasMaquinas });
+        // RM-053 (D9): depois da entrega ao dono, a mesma batida publica o retrato desta maquina na rede da
+        // pessoa (so membro, uma tentativa a cada 14 min, retrato igual so de hora em hora).
+        const r = varrerEDepoisPublicarNaRede(() => varrerPulse({ raiz, escopo, comCadencia: true, outrasMaquinas }), () => {
+            try {
+                const rede = (0, rede_1.publicarRedeNaBatida)({ diretorio: carregado.raiz });
+                if (rede)
+                    (0, rede_adesao_1.registrarNaRede)({ ...rede, origem: 'pulse' });
+            }
+            catch (e) {
+                (0, rede_adesao_1.registrarNaRede)({ acao: 'falhou', origem: 'pulse', erro: e.message });
+            }
+        });
         console.log(JSON.stringify(r));
         process.exitCode = r.code;
     }