@orkastery/cli 0.4.3 → 0.5.1

package/dist/prova-ativacao.js

@@ -0,0 +1,345 @@
+"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.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 ou OpenClaw), 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'];
+/**
+ * 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`. `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' }],
+};
+const SHELL_DO_HOST = { 'claude-code': 'Bash', openclaw: 'exec' };
+const ORK_MAESTRO_NO_SHELL = /(^|[\s;&|(/])ork(\s+(--projeto|--project|-p)(\s+|=)\S+)?\s+maestro\b/;
+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 };
+}
+/** 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-consentimento.js

@@ -72,6 +72,7 @@ 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");
+const hitl_texto_livre_1 = require("./hitl-texto-livre");
 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,
@@ -140,7 +141,8 @@ function interpretarResposta(bruto, codigo) {
         return 'sim';
     if (['b', 'n', 'nao', 'não', 'agora nao', 'agora não'].includes(corpo))
         return 'nao';
-    return undefined;
+    // RM-048 (D2): o mesmo vocabulario fechado do texto livre ("pode seguir", "aprovo", "depois").
+    return (0, hitl_texto_livre_1.consentimentoDoTrecho)((0, hitl_texto_livre_1.lerTrecho)(corpo));
 }
 /**
  * A assinatura de um conjunto de candidatos: os mesmos gates, a mesma oferta. O pedido aberto nao
@@ -234,7 +236,7 @@ function responderConsentimento(raiz, entrada) {
         }
         return { resposta: estado.respondido.resposta, repetida: true, pedido, respondido: estado.respondido };
     }
-    if (Date.parse(quando) >= Date.parse(pedido.prazo)) {
+    if (Date.parse(quando) >= Date.parse(pedido.prazo) && entrada.aceitarVencido !== true) {
         throw new Error('consentimento do pulse: pedido vencido; nenhuma autorização concedida');
     }
     if (!resposta)

package/dist/pulse-delivery.js

@@ -33,7 +33,7 @@ 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;
@@ -63,6 +63,8 @@ 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 +185,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 +222,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,17 +247,23 @@ 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 });
             // 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,
                 resumoSha256: assinaturaDoResumo(resumo), candidatos: fila.candidatos, prazoMin: Math.max(janelaMin, pulse_consentimento_1.PRAZO_PADRAO_MIN), estadoDir: dir })) : undefined;
             entregar((0, hitl_resumo_1.textoDoResumo)(resumo, { canal, codigo: consentimento?.codigo }), 'o resumo');
+            // RM-048 (D3): o resumo acabou de sair; a palavra solta ("sim") vale na janela curta dele.
+            try {
+                (0, pulse_resposta_1.atualizarEscuta)(raiz, quando, dir);
+            }
+            catch { /* dica de rota; a prova nao depende dela */ }
             // Marcado so depois do recibo do transporte: envio que falhou preserva a novidade.
             for (const item of itens)
                 vistas[item.id] = assinaturaPulse(item);
@@ -247,6 +271,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);