@orkastery/cli 0.5.0 → 0.5.1

package/dist/policies.js

@@ -96,6 +96,17 @@ exports.POLICIES_CONHECIDAS = {
         descricao: 'avisa quando a branch da thread esta atras da base',
     },
 };
+/**
+ * Ensaio da 0.5.0: a thread criada sem `--worktree auto` entrega a base para a base, e a correcao
+ * repetia o proprio `ork ship`. A thread que ainda nao passou do GO ganha a branch com
+ * `ork worktree ensure`. Depois do GO, nao: os commits ja estao na base, a branch nova nasce com eles
+ * e o ship sem delta empurraria a base direto, que e o que esta policy barra (CHECK, rodada 1).
+ */
+function correcaoSemBranchDaThread(threadId, base) {
+    return `entregue a branch da thread (ork/<slug>) com --para ${base || '<base>'}; sem worktree e antes do GO, ` +
+        `crie-a com ork worktree ensure ${threadId || '<thread>'} (thread nova: --worktree auto); depois do GO, ` +
+        'os commits ja estao na base e o ship nao os separa: leve-os para a branch da thread antes de entregar';
+}
 function severidade(bruta) {
     if (bruta === 'block' || bruta === 'warn' || bruta === 'off')
         return bruta;
@@ -158,7 +169,7 @@ function avaliarPolicies(manifesto, ctx) {
                     severidade: sev,
                     motivo: 'policy.violation',
                     detalhe: `origem e destino sao a mesma branch ("${de}"): isso e push direto na base, nao merge de thread`,
-                    correcao: 'entregue a partir da branch da thread: ork ship <thread> --para ' + (base || 'main'),
+                    correcao: correcaoSemBranchDaThread(ctx.threadId, base),
                 });
             }
             else if (de && base && de === base) {
@@ -167,7 +178,21 @@ function avaliarPolicies(manifesto, ctx) {
                     severidade: sev,
                     motivo: 'policy.violation',
                     detalhe: `a origem "${de}" e a propria branch base do projeto: nenhuma branch de thread foi usada`,
-                    correcao: 'crie a thread com --worktree auto e entregue a branch ork/<slug>',
+                    correcao: correcaoSemBranchDaThread(ctx.threadId, base),
+                });
+            }
+            else if (ctx.semDeltaComBaseAFrente === true) {
+                // Fatia 2 do ensaio da 0.5.0 (P9): a thread que perdeu a branch depois do GO ganha uma com os commits
+                // ja na base; o ship ve nada a mergear e empurraria a base, que e o que esta policy barra.
+                const remoto = ctx.remoto ?? 'origin';
+                violacoes.push({
+                    policy: nome,
+                    severidade: sev,
+                    motivo: 'policy.violation',
+                    detalhe: `a branch "${de}" nao traz commit alem de "${para}", e ${para} local tem commit que ${remoto}/${para} nao tem: ` +
+                        'o ship empurraria a base direto, sem merge de thread',
+                    correcao: `leve os commits que estao so em ${para} local para a branch da thread antes de entregar, ou entregue-os ` +
+                        `pela thread que os criou (conferido em refs/remotes/${remoto}/${para}, sem rede)`,
                 });
             }
             continue;

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-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,12 +247,13 @@ 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,
@@ -252,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);

package/dist/pulse.js

@@ -26,6 +26,8 @@ const decisao_autonoma_1 = require("./decisao-autonoma");
 const docs_1 = require("./docs");
 const conducao_1 = require("./conducao");
 const conducao_texto_1 = require("./conducao-texto");
+const hitl_resumo_1 = require("./hitl-resumo");
+const parado_no_condutor_1 = require("./parado-no-condutor");
 exports.CONTRATO_PULSE = 'ork.pulse/v1';
 /** Uma semana: o resumo cita a decisao uma vez, e ela continua lida ate sair da janela. */
 exports.JANELA_DAS_DECISOES_MS = 7 * 24 * 60 * 60 * 1000;
@@ -47,6 +49,17 @@ function apresentacaoCurtaDoItem(pedido, desde, quando) {
 function comporPulse(carregado, entrada) {
     const { radar, monitor, batch, orfas } = entrada, quando = radar.consultadoEm;
     const humanos = [], automaticas = [];
+    // RM-037 (fatia 4): o fim de turno sem pergunta e do condutor. Ele sai da fila do dono aqui e volta
+    // como linha propria (`paradoNoCondutor`); leitura que falha nao esconde nada do dono.
+    let entregas = entrada.entregas;
+    if (!entregas) {
+        try {
+            entregas = (0, parado_no_condutor_1.entregasDoProjeto)(carregado, { quando, sessoes: radar.sessoes });
+        }
+        catch {
+            entregas = undefined;
+        }
+    }
     const registros = new Map();
     const ehRegistro = (id) => {
         if (!id)
@@ -79,6 +92,11 @@ function comporPulse(carregado, entrada) {
     };
     const TERMINAIS = ['failed', 'done', 'stopped', 'completed'];
     for (const s of radar.sessoes.filter(s => s.precisaDeHumano)) {
+        // RM-037 (fatia 4): sessao `blocked` de quem o turno acabou sem pergunta e do condutor: a que o ledger provou
+        // (Stop sem atividade depois; a lista numerada da mensagem final nao e menu) e a sobra sem menu na tela.
+        if (entregas?.doCondutor.sessoes.has(s.sessionId) &&
+            ((0, parado_no_condutor_1.sessaoSemPergunta)(s) || entregas.doCondutor.turnosEncerrados.has(s.sessionId)))
+            continue;
         // Job morto ou estado terminal é história. Bloqueio vivo ou desconhecido continua visível.
         if (ehRegistro(s.thread?.id ?? null) && s.jobVivo !== true &&
             (s.jobVivo === false || TERMINAIS.includes(s.estadoBruto)))
@@ -123,6 +141,9 @@ function comporPulse(carregado, entrada) {
         for (const p of l.paradas) {
             if (VERIFICACAO.includes(p.motivo) && jaMesclada(l.thread))
                 continue;
+            // RM-037 (fatia 4): o `human.pending` que o observador grava no fim de turno sem pergunta nao e do dono.
+            if (p.motivo === 'human.pending' && p.fonte === 'ledger' && entregas?.doCondutor.gates.has(`${l.thread}|${p.fase}`))
+                continue;
             if (ehRegistro(l.thread)) {
                 if (p.fonte === 'escalonador' || ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'vaga.stale', 'runtime.silencio'].includes(p.motivo))
                     continue;
@@ -216,7 +237,8 @@ function comporPulse(carregado, entrada) {
         }
     }
     return { contrato: exports.CONTRATO_PULSE, consultadoEm: quando, runtime: { ok: radar.runtimeConsultado, detalhe: radar.runtimeDetalhe },
-        precisaDeHumanoAgora: h, acoesAutomaticas: a, resumo: { humanos: h.length, automaticas: a.length, scores: batch.length, fasesOrfas: orfas.length } };
+        precisaDeHumanoAgora: h, acoesAutomaticas: a, resumo: { humanos: h.length, automaticas: a.length, scores: batch.length, fasesOrfas: orfas.length },
+        ...(entregas?.parados.length ? { paradoNoCondutor: entregas.parados } : {}) };
 }
 function montarPulse(carregado, opcoes = {}) {
     if (opcoes.registrar)
@@ -243,7 +265,27 @@ function montarPulse(carregado, opcoes = {}) {
             }
         }
     const monitor = (0, orquestracao_1.montarMonitor)(carregado, { agora: quando, estados });
-    const pulse = comporPulse(carregado, { radar, monitor, orfas, batch: (0, master_1.pendentesDeScore)(carregado.raiz) });
+    // RM-037 (fatia 4, D2): a forja so e lida quando alguma thread tem branch publicada; a leitura boa vira o
+    // retrato que o status do roadmap le sem rede. Falha de leitura e diagnostico, nunca "sem PR".
+    let entregas;
+    try {
+        entregas = (0, parado_no_condutor_1.entregasDoProjeto)(carregado, { quando, sessoes: radar.sessoes, lerPrs: (candidatas) => {
+                const leitura = (0, parado_no_condutor_1.lerPrsDaForja)(carregado, { quando, executor: opcoes.executorDoGh, candidatas });
+                if (leitura.ok) {
+                    try {
+                        (0, parado_no_condutor_1.gravarRetratoDePrs)(carregado.raiz, leitura.retrato);
+                    }
+                    catch { /* o retrato e economia do status */ }
+                }
+                return leitura;
+            } });
+        if (entregas.prs && !entregas.prs.ok)
+            diagnosticos.push(`prs.nao-lidos: ${entregas.prs.erro.slice(0, 160)}`);
+    }
+    catch (e) {
+        diagnosticos.push(`entregas.indisponiveis: ${e.message.slice(0, 120)}`);
+    }
+    const pulse = comporPulse(carregado, { radar, monitor, orfas, batch: (0, master_1.pendentesDeScore)(carregado.raiz), ...(entregas ? { entregas } : {}) });
     const conducoes = monitor.linhas.filter((l) => l.conducao).map((l) => ({ thread: l.thread, linha: (0, conducao_texto_1.linhaDeConducao)(l.conducao, { agora: quando }) }));
     if (conducoes.length > 0)
         pulse.conducoes = conducoes;
@@ -264,8 +306,10 @@ function textoDoPulse(p) {
     // I-35: o pulse guarda ISO; o texto ao dono sai no fuso dele, rotulado no cabeçalho.
     const local = (texto) => (0, horario_1.localizarTexto)(texto, { agora: p.consultadoEm });
     const linhas = [`Pulse (${p.contrato}) ${(0, horario_1.formatarDataHoraRotulada)(p.consultadoEm, { agora: p.consultadoEm })}`, `Precisa de humano agora: ${p.resumo.humanos}`, `${p.resumo.scores} entrega(s) sem nota, aceitas por padrão com registro`];
-    if (p.runtime.ok && p.runtime.detalhe.includes('liveness.snapshot.invalid'))
+    // RM-037 (fatia 4): PR nao lido tambem e dito, para a falta de linha do condutor nao parecer "nada parado".
+    if (p.runtime.ok && ['liveness.snapshot.invalid', 'prs.nao-lidos', 'entregas.indisponiveis'].some(d => p.runtime.detalhe.includes(d))) {
         linhas.push(`[diagnostico] ${local(p.runtime.detalhe)}`);
+    }
     if (!p.runtime.ok)
         linhas.push(`[consulta incompleta] ${local(p.runtime.detalhe)}`);
     for (const i of p.precisaDeHumanoAgora) {
@@ -276,6 +320,12 @@ function textoDoPulse(p) {
         for (const c of p.conducoes)
             linhas.push(`${c.thread}: ${c.linha}`);
     }
+    // RM-037 (fatia 4): o que espera o condutor, uma linha por thread; nao e pergunta ao dono.
+    if (p.paradoNoCondutor?.length) {
+        linhas.push('', `Parado no condutor: ${p.paradoNoCondutor.length}`);
+        for (const x of p.paradoNoCondutor)
+            linhas.push((0, hitl_resumo_1.linhaDoParadoNoCondutor)(x, { agora: p.consultadoEm }));
+    }
     linhas.push('', `Ações automáticas pendentes: ${p.resumo.automaticas}`);
     for (const i of p.acoesAutomaticas)
         linhas.push(`${i.thread}: ${i.motivo}; ${i.comandoResposta}`);