@orkastery/cli 0.4.3 → 0.5.0

package/dist/master-batch.js

@@ -24,7 +24,7 @@ function listarBatch(raiz, todas = false) {
     return (0, master_1.pendentesDeScore)(raiz, todas).map(p => ({ thread: p.thread.id, nome: p.thread.nome, entregue: p.entregou,
         proposta: p.thread.score_proposto ?? null, assinatura: p.thread.score_proposto ? assinaturaProposta(p.thread.score_proposto) : null }));
 }
-function ratificarBatch(raiz, selecao, por) {
+function ratificarBatch(raiz, selecao, por, prova) {
     (0, master_1.exigirAutoriaHumana)(por);
     if (!selecao.length || new Set(selecao.map(s => s.thread)).size !== selecao.length)
         throw new Error('selecione threads distintas explicitamente');
@@ -34,7 +34,8 @@ function ratificarBatch(raiz, selecao, por) {
         if (!item?.proposta || item.assinatura !== s.assinatura)
             throw new Error(`proposta ausente ou alterada: ${s.thread}; revise o batch`);
         const p = item.proposta;
-        const opcoes = { score: p.valor, justificativa: p.justificativa, classes: s.classe ? [s.classe] : p.classes, resumo: p.resumo, por };
+        const opcoes = { score: p.valor, justificativa: p.justificativa, classes: s.classe ? [s.classe] : p.classes, resumo: p.resumo, por,
+            ...(prova ? { prova } : {}) };
         (0, master_1.preflightMaster)(raiz, s.thread, opcoes);
         return { id: s.thread, opcoes };
     });

package/dist/master-digest.js

@@ -100,14 +100,14 @@ function lerDigest(raiz, semana) {
         throw new Error('digest inválido');
     return job;
 }
-function responderLoteDigest(raiz, resposta, por) {
+function responderLoteDigest(raiz, resposta, por, prova) {
     const partes = resposta.trim().split(/\s+/);
     if (partes.length !== 3 || partes[0] !== 'ratificar-lote')
         throw new Error('resposta de lote inválida');
     const job = lerDigest(raiz, partes[1]);
     if (!job.concluidoEm || partes[2] !== job.assinatura)
         throw new Error('lote não entregue ou assinatura divergente');
-    return (0, master_batch_1.ratificarBatch)(raiz, job.selecao, por);
+    return (0, master_batch_1.ratificarBatch)(raiz, job.selecao, por, prova);
 }
 function enviarDigest(opcoes) {
     const quando = opcoes.quando ?? new Date().toISOString(), semana = sextaLocal(quando);

package/dist/master-nota.js

@@ -0,0 +1,203 @@
+"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.ERRO_PROVA_DE_CANAL = exports.CONTRATO_PEDIDO_DE_NOTA = void 0;
+exports.exigirNotaSemHost = exigirNotaSemHost;
+exports.arquivoDasNotas = arquivoDasNotas;
+exports.pedirNota = pedirNota;
+exports.pedidoDeNotaDoCodigo = pedidoDeNotaDoCodigo;
+exports.textoDoPedidoDeNota = textoDoPedidoDeNota;
+exports.lerNota = lerNota;
+exports.reciboDoCanal = reciboDoCanal;
+exports.mensagemJaUsadaEmNota = mensagemJaUsadaEmNota;
+/**
+ * RM-048 (item 8, D8): a nota do MASTER com prova de origem humana.
+ *
+ * Ate aqui toda nota gravava o nome que viesse em `--por`: a `ork_master` do OpenClaw repassava o
+ * parametro `quem` do modelo, e `master ratificar`, `batch --aceitar` e `digest responder` idem.
+ * `autoriaHumana` so recusa nome de agente; ela mesma diz que nao e autenticacao. O dono pediu que
+ * a nota dada por ferramenta de host passe pela MESMA prova de canal que o gate ja exige.
+ *
+ * O caminho com prova e este, e ele nao cria autenticacao nova:
+ *
+ *   1. `ork master pedir <thread>` guarda um pedido de nota com codigo curto e devolve a linha
+ *      "<codigo> <0 a 5> <porque>" para o canal mostrar ao dono;
+ *   2. o dono responde no Telegram; o ingresso (Hermes ou OpenClaw) assina o texto dele no
+ *      endereco do pulse, com a chave do proprio canal, e o nucleo confere com a mesma
+ *      `autenticarResposta` de sempre, ANTES de ler o conteudo;
+ *   3. a nota e gravada com `por` = o remetente autenticado (`telegram:<id>`) e com o recibo:
+ *      canal, conta, mensagem, instante, o sha da prova e o envelope assinado guardado para a
+ *      auditoria reconferir o HMAC depois.
+ *
+ * O teclado do digest semanal ("ratificar <thread> <assinatura> <classe>") passa pelo mesmo
+ * endereco. E o processo de host (Claude Code, Codex, Hermes, OpenClaw, sessao despachada) que
+ * tenta gravar nota com `--por` recebe `master.prova-de-canal`.
+ *
+ * LIMITE DITO: o canal do processo e declarado pelo ambiente (`canalDoProcesso`). Ele serve para
+ * RECUSAR, nunca para autorizar, e um agente que apague as variaveis do proprio host de proposito
+ * passa como terminal. Essa e a mesma fronteira do `humano-no-cli` do SHIP; fecha-la de vez exige o
+ * dialogo nativo do host para a nota, que fica fora desta entrega.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const thread_1 = require("./thread");
+const ledger_1 = require("./ledger");
+const thread_close_1 = require("./thread-close");
+const conducao_1 = require("./conducao");
+const pulse_consentimento_1 = require("./pulse-consentimento");
+const monitor_lock_1 = require("./monitor-lock");
+exports.CONTRATO_PEDIDO_DE_NOTA = 'ork.master-nota/v1';
+exports.ERRO_PROVA_DE_CANAL = 'master.prova-de-canal';
+const sha = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
+/**
+ * D8: nota em nome de pessoa, vinda de processo de host, e recusada. O canal e lido SO do
+ * ambiente: `--canal` em argv nao conta, porque quem escreve argv e justamente quem chama.
+ */
+function exigirNotaSemHost(ambiente = process.env) {
+    let canal;
+    try {
+        canal = (0, conducao_1.canalDoProcesso)(undefined, ambiente);
+    }
+    catch {
+        canal = 'mcp';
+    }
+    // B2 do CHECK: `ORK_CANAL=cli` NAO absolve. A sessao despachada herda `ORK_CANAL=cli` quando a
+    // thread e conduzida do terminal, e o Claude Code e o Codex marcam os proprios processos. Qualquer
+    // marca de host ou de despacho recusa, mesmo com o canal declarado como terminal.
+    const marca = canal !== 'cli' ? canal
+        : ambiente.ORK_DISPATCH_ID ? 'sessão despachada (ORK_DISPATCH_ID)'
+            : ambiente.CLAUDECODE === '1' ? 'claude-code (CLAUDECODE)'
+                : ambiente.CODEX_SANDBOX || ambiente.CODEX_SANDBOX_NETWORK_DISABLED ? 'codex (CODEX_SANDBOX)'
+                    : (ambiente.HERMES_HOME ?? '').trim() ? 'hermes (HERMES_HOME)' : undefined;
+    if (marca) {
+        throw new Error(`${exports.ERRO_PROVA_DE_CANAL}: nota em nome de pessoa vinda de ${marca} exige a prova de canal do ingresso. ` +
+            'Peça a nota com ork master pedir <thread>: o dono responde pelo Telegram com o código, e a nota é gravada com o recibo.');
+    }
+}
+function arquivoDasNotas(raiz, estadoDir) {
+    return path.join(estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor'), 'master-notas.json');
+}
+function lerNotas(raiz, estadoDir) {
+    const arquivo = arquivoDasNotas(raiz, estadoDir);
+    if (!fs.existsSync(arquivo))
+        return {};
+    const v = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+    if (v.contrato !== exports.CONTRATO_PEDIDO_DE_NOTA || !v.notas || typeof v.notas !== 'object')
+        throw new Error('pedidos de nota: estado inválido; exige inspeção');
+    return v.notas;
+}
+function gravarNotas(raiz, notas, estadoDir) {
+    const arquivo = arquivoDasNotas(raiz, estadoDir);
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    const tmp = `${arquivo}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ contrato: exports.CONTRATO_PEDIDO_DE_NOTA, notas }) + '\n', { mode: 0o600 });
+    fs.renameSync(tmp, arquivo);
+}
+/**
+ * Pede a nota ao dono. Idempotente: a mesma entrega sem nota devolve o MESMO codigo, para a
+ * linha que o dono recebeu nao vencer. So entrega provada recebe pedido de nota.
+ */
+function pedirNota(raiz, thread, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    (0, thread_close_1.exigirEntrega)(raiz, thread);
+    const estadoDir = opcoes.estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor');
+    // A4 do CHECK: o registro dos pedidos de nota tem dois escritores (pedir e o receptor do pulse);
+    // um de cada vez, pelo mesmo lock da conversa.
+    return (0, monitor_lock_1.comLockDaConversa)(estadoDir, () => {
+        const notas = lerNotas(raiz, estadoDir);
+        const existente = Object.values(notas).find(n => n.thread === thread);
+        if (existente && !notaDada(raiz, existente))
+            return existente;
+        // A1 do CHECK: o codigo da nota nao repete o de gate aberto nem o do resumo (quem chama passa).
+        const codigo = (0, pulse_consentimento_1.gerarCodigo)([...Object.keys(notas), ...(opcoes.codigosEmUso ?? [])]);
+        const pedido = { contrato: exports.CONTRATO_PEDIDO_DE_NOTA, pedidoId: (0, node_crypto_1.randomUUID)(), thread, codigo, criadoEm: quando };
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread), thread, ledger_1.TIPOS_DE_EVENTO.notaPedida, { fase: 'MASTER', pedidoId: pedido.pedidoId, codigo });
+        gravarNotas(raiz, { ...Object.fromEntries(Object.entries(notas).filter(([, n]) => n.thread !== thread)), [codigo]: pedido }, estadoDir);
+        return pedido;
+    });
+}
+/** A nota deste pedido ja foi dada pelo canal. */
+function notaDada(raiz, p) {
+    return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, p.thread)).some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.masterConcluido &&
+        e.notaPedida?.pedidoId === p.pedidoId);
+}
+/** O pedido de nota que usa este codigo, quando ha um. */
+function pedidoDeNotaDoCodigo(raiz, codigo, estadoDir) {
+    try {
+        return lerNotas(raiz, estadoDir)[codigo.trim().toUpperCase()];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A linha que o canal mostra ao dono. Uma linha de contexto e uma de resposta. */
+function textoDoPedidoDeNota(raiz, p, canal) {
+    const t = (0, thread_1.lerThread)(raiz, p.thread);
+    const tg = canal === 'telegram';
+    return [
+        `${tg ? '🧾 ' : ''}Nota da entrega ${p.thread} (${t.nome.slice(0, 80)})`,
+        `${tg ? '• ' : '- '}Sem nota, vale a aceita por omissão, com o índice derivado do ledger ao lado.`,
+        `${tg ? '↩️ ' : ''}Responda: ${p.codigo} <0 a 5> <porquê>, por exemplo: ${p.codigo} 4 entregou o que pedi.`,
+    ].join('\n');
+}
+/** "4 entregou o que pedi" vira nota e justificativa; o resto e devolvido como pergunta. */
+function lerNota(resto) {
+    const m = /^\s*([0-5])(?:\s*\/\s*5)?\s*[-:,.]?\s+(\S[\s\S]{2,})$/.exec(resto);
+    return m ? { score: Number(m[1]), justificativa: m[2].trim() } : undefined;
+}
+/**
+ * O recibo que acompanha a nota no `master_done`. O envelope assinado inteiro fica guardado, para
+ * que a auditoria reconfira o HMAC do canal depois (`autenticarResposta` no instante recebido). Um
+ * arquivo por mensagem: a mesma mensagem nunca vira duas notas.
+ */
+function reciboDoCanal(raiz, envelope, vinculo, estadoDir) {
+    const dir = path.join(estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor'), 'master-nota');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const arquivo = path.join(dir, `${sha(envelope.mensagem)}.json`);
+    const corpo = JSON.stringify({ contrato: exports.CONTRATO_PEDIDO_DE_NOTA, vinculo, envelope }) + '\n';
+    if (!fs.existsSync(arquivo))
+        fs.writeFileSync(arquivo, corpo, { mode: 0o600, flag: 'wx' });
+    return {
+        origem: envelope.origem, canal: envelope.canal ?? null, conta: envelope.conta ?? null, mensagem: envelope.mensagem,
+        recebidoEm: envelope.recebidoEm, recibo: sha(envelope.prova), contratoResposta: envelope.canal === undefined ? 'ork.hitl-answer/v1' : 'ork.hitl-answer/v2',
+        evidencia: path.relative((0, estado_thread_1.raizDoEstado)(raiz), arquivo), evidenciaSha256: sha(fs.readFileSync(arquivo, 'utf8')), ...vinculo,
+    };
+}
+/** Mensagem ja usada numa nota desta thread nao vale de novo, igual ao gate. */
+function mensagemJaUsadaEmNota(raiz, thread, mensagem) {
+    return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread)).some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.masterConcluido && e.mensagem === mensagem);
+}

package/dist/master.js

@@ -88,6 +88,7 @@ const horario_1 = require("./horario");
 const indice_1 = require("./indice");
 const ship_1 = require("./ship");
 const fabrica_publicar_1 = require("./fabrica-publicar");
+const fechamento_1 = require("./fechamento");
 /** Identificador do contrato congelado do MASTER log. */
 exports.CONTRATO_MASTER_LOG = 'ork.master-log/v1';
 /** Versao do contrato. Uma mudanca de contrato exige uma versao nova, nao um campo novo. */
@@ -392,7 +393,10 @@ function registrarMaster(raiz, id, opcoes) {
         classesDeFalha: masterLog.classesDeFalha, regime: postmortem.score.regime,
         contrato: exports.CONTRATO_MASTER_LOG, arquivo: path.relative((0, estado_thread_1.raizDoEstado)(raiz), r.caminhoMasterLog), estado: 'thread fechada',
         masterLogSha256: hashDocumento(r.caminhoMasterLog), postmortemSha256: hashDocumento(r.caminhoPostmortem),
+        ...(opcoes.prova ? { prova: 'ingresso-autenticado', ...opcoes.prova } : {}),
     });
+    // RM-037 (rm037noite): a thread fechada solta o que segurava, com registro no ledger dela.
+    (0, fechamento_1.liberarAoFechar)(raiz, id);
     return r;
 }
 exports.CONTRATO_MASTER_PENDENTE = 'ork.master-pending/v1';

package/dist/mcp-experiencia.js

@@ -0,0 +1,164 @@
+"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.consultaExperienciaSchema = void 0;
+exports.apresentarConsulta = apresentarConsulta;
+exports.consultarPainel = consultarPainel;
+exports.criarLeitorExperiencia = criarLeitorExperiencia;
+exports.registrarConsultasExperiencia = registrarConsultasExperiencia;
+/** Consultas do projeto fixado. Nunca reserva item, publica máquina ou executa push. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const zod_1 = require("zod");
+const roadmap_reservas_1 = require("./roadmap-reservas");
+const fabrica_estado_1 = require("./fabrica-estado");
+const mcp_ship_1 = require("./mcp-ship");
+const mcp_git_1 = require("./mcp-git");
+exports.consultaExperienciaSchema = zod_1.z.object({}).strict();
+function apresentarConsulta(painel) {
+    const estado = painel.atualizado ? 'atualizado' : painel.ponta ? 'desatualizado' : 'indisponivel';
+    return { estado, dados: estado === 'indisponivel' ? null : painel,
+        motivo: estado === 'atualizado' ? null : 'mcp.experiencia.remoto.indisponivel' };
+}
+const indisponivel = () => ({ estado: 'indisponivel', dados: null, motivo: 'mcp.experiencia.consulta.indisponivel' });
+/** Chamada somente depois de validar a fixação do worker. */
+function consultarPainel(raiz, tipo) {
+    try {
+        return apresentarConsulta(tipo === 'reservas' ? (0, roadmap_reservas_1.listarReservas)(raiz, { remoto: 'origin' })
+            : (0, fabrica_estado_1.lerFabrica)(raiz, { remoto: 'origin', timeoutMs: 15000 }));
+    }
+    catch {
+        return indisponivel();
+    }
+}
+/** Usa as mesmas guardas de transporte do núcleo; não cria autorização de SHIP. */
+function assinatura(raiz, transporte) {
+    (0, mcp_ship_1.criarPerfilShipMcp)(raiz, transporte);
+    const g = path.join(raiz, '.git');
+    (0, mcp_git_1.perfilGitMcp)(raiz, g, g, 'consulta-experiencia', []);
+    const st = fs.statSync(raiz);
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify([st.dev, st.ino, fs.realpathSync(raiz),
+        (0, mcp_git_1.gitPassivoMcp)(raiz, ['remote', 'get-url', '--all', 'origin']),
+        (0, mcp_git_1.gitPassivoMcp)(raiz, ['config', '--null', '--list'])])).digest('hex');
+}
+const PRAZO_DA_CONSULTA_MS = 90000;
+/**
+ * O worker herda somente ambiente permitido; nunca modifica env do servidor. Roda assíncrono para
+ * o servidor MCP seguir atendendo as outras tools durante a consulta remota, e em grupo próprio:
+ * prazo ou cancelamento da chamada matam o worker e o git que ele abriu.
+ */
+function criarLeitorExperiencia(raiz, transporte, prazoMs = PRAZO_DA_CONSULTA_MS) {
+    let fixacao = null;
+    try {
+        fixacao = assinatura(raiz, transporte);
+    }
+    catch { /* ferramenta continua descoberta, com lacuna explícita */ }
+    return (tipo, signal) => new Promise(resolve => {
+        if (!fixacao || signal?.aborted) {
+            resolve(indisponivel());
+            return;
+        }
+        const grupo = process.platform !== 'win32';
+        const filho = (0, node_child_process_1.spawn)(process.execPath, [__filename, '--consulta-experiencia'], {
+            cwd: raiz, env: { ...(0, mcp_git_1.ambienteGitMcp)(), SSH_AUTH_SOCK: process.env.SSH_AUTH_SOCK },
+            stdio: ['pipe', 'pipe', 'ignore'], detached: grupo,
+        });
+        let saida = '', terminado = false;
+        const concluir = (r) => {
+            if (terminado)
+                return;
+            terminado = true;
+            clearTimeout(prazo);
+            signal?.removeEventListener('abort', abortar);
+            resolve(r);
+        };
+        const abortar = () => {
+            if (terminado)
+                return;
+            filho.stdout?.destroy();
+            try {
+                if (filho.pid)
+                    process.kill(grupo ? -filho.pid : filho.pid, 'SIGKILL');
+            }
+            catch { /* já terminou */ }
+            concluir(indisponivel());
+        };
+        const prazo = setTimeout(abortar, prazoMs);
+        signal?.addEventListener('abort', abortar, { once: true });
+        filho.stdout.setEncoding('utf8');
+        filho.stdout.on('data', (parte) => { saida += parte; if (saida.length > 1024 * 1024)
+            abortar(); });
+        filho.stdin.on('error', () => undefined);
+        filho.on('error', () => concluir(indisponivel()));
+        filho.on('close', (codigo, sinal) => {
+            if (codigo !== 0 || sinal) {
+                concluir(indisponivel());
+                return;
+            }
+            try {
+                concluir(JSON.parse(saida));
+            }
+            catch {
+                concluir(indisponivel());
+            }
+        });
+        filho.stdin.end(JSON.stringify({ raiz, transporte, fixacao, tipo }));
+    });
+}
+function registrarConsultasExperiencia(registrar, opcoes) {
+    const ler = criarLeitorExperiencia(opcoes.raiz, opcoes.transporte);
+    for (const [nome, tipo] of [['ork_roadmap_reservas', 'reservas'], ['ork_fabrica', 'fabrica']]) {
+        registrar(nome, { description: 'Consulta de ' + tipo + ' do projeto e origin fixados; distingue remoto atualizado, cópia desatualizada e indisponibilidade. Não reserva nem publica.',
+            inputSchema: exports.consultaExperienciaSchema, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true } }, async (_args, extra) => {
+            opcoes.carregar();
+            return { content: [{ type: 'text', text: JSON.stringify(await ler(tipo, extra.signal)) }] };
+        });
+    }
+}
+if (require.main === module && process.argv[2] === '--consulta-experiencia') {
+    try {
+        const p = zod_1.z.object({ raiz: zod_1.z.string(), transporte: zod_1.z.enum(['github-ssh', 'bare-local']),
+            fixacao: zod_1.z.string().regex(/^[a-f0-9]{64}$/), tipo: zod_1.z.enum(['reservas', 'fabrica']) }).strict()
+            .parse(JSON.parse(fs.readFileSync(0, 'utf8')));
+        if (assinatura(p.raiz, p.transporte) !== p.fixacao)
+            throw Error('scope.changed');
+        process.stdout.write(JSON.stringify(consultarPainel(p.raiz, p.tipo)));
+    }
+    catch {
+        process.stdout.write(JSON.stringify(indisponivel()));
+    }
+}

package/dist/mcp-git.js

@@ -131,6 +131,10 @@ function configPassiva(chave, valor, credenciaisInertes = false) {
         return valor.length <= 8192 && !valor.includes('\0');
     if (['user.name', 'user.email'].includes(chave))
         return !!valor.trim() && valor.length <= 512 && !/[\x00-\x1f]/.test(valor);
+    // RM-051: só afrouxa a checagem de dono, e o Git só a lê no sistema ou no global; o repositório
+    // continua conferido chave a chave aqui. A imagem do runner hospedado do GitHub grava `safe.directory=*`.
+    if (chave === 'safe.directory')
+        return valor.length <= 4096 && !/[\x00-\x1f\x7f]/.test(valor);
     // RM-037 (defeitosdeco D-3): a seção do próprio produto (por exemplo `orkastery.cortefeito`, lida
     // pela trava do corte no pre-push). O Git nunca lê essa seção, então ela não executa nada.
     if (/^orkastery\.[a-z0-9-]+$/.test(chave))

package/dist/mcp-install.js

@@ -47,7 +47,9 @@ const node_util_1 = require("node:util");
 const smol_toml_1 = require("smol-toml");
 const manifest_1 = require("./manifest");
 exports.TOOLS_DONO_CODEX = ['ork_thread_new', 'ork_phase_run', 'ork_request_decision'];
-exports.TOOLS_FILHO_CODEX = ['ork_artifact_write', 'ork_claim_add', 'ork_git_commit', 'ork_verify', 'ork_ship'];
+// RM-037 (rm037defeito, defeito 1): a decisao autonoma da sessao entra com as outras mutacoes do filho;
+// sem o grant, o codex com approval_policy never recusaria a chamada.
+exports.TOOLS_FILHO_CODEX = ['ork_artifact_write', 'ork_claim_add', 'ork_decision_record', 'ork_git_commit', 'ork_verify', 'ork_ship'];
 // Brain mutation tools are deliberately excluded from the existing opt-in bundle.
 // A native integration must request exact startup grants plus scoped activation.
 var company_brain_mcp_1 = require("./company-brain-mcp");

package/dist/mcp-maestro.js

@@ -9,7 +9,7 @@ const maestro_cli_1 = require("./maestro-cli");
 exports.maestroInputSchema = zod_1.z.object({ threadId: zod_1.z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/).optional(),
     section: zod_1.z.enum(maestro_contract_1.SECTION_NAMES).optional(), offset: zod_1.z.number().int().min(0).max(100000).optional() }).strict();
 function registerMaestro(register, options) {
-    register('ork_maestro', { description: 'Panorama Maestro somente leitura, fixado ao projeto e ao escopo da sessão; cobertura, lacunas e próximas ações pelos endpoints existentes.',
+    register('ork_maestro', { description: 'Panorama Maestro somente leitura, fixado ao projeto e ao escopo da sessão; cobertura, lacunas e próximas ações pelos endpoints existentes. Não lê o roadmap, as reservas nem as outras máquinas (veja notConsulted): zero threads nunca é roadmap vazio; para o roadmap, com as threads de todas as máquinas, use ork_network_roadmap.',
         inputSchema: exports.maestroInputSchema, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false } }, async (args) => {
         options.load();
         if ((args.section === undefined) !== (args.offset === undefined))
@@ -17,7 +17,8 @@ function registerMaestro(register, options) {
         const threadId = args.threadId ?? options.threadId;
         if (threadId)
             options.checkThread(threadId);
-        const context = (0, maestro_discovery_1.discoverMaestro)({ cwd: options.root, pinned: options.root });
+        // RM-052 (D5): fixado no projeto servido; os outros projetos da maquina nao entram na conta.
+        const context = (0, maestro_discovery_1.discoverMaestro)({ cwd: options.root, pinned: options.root, countOtherProjects: false });
         const result = (0, maestro_cli_1.readMaestro)(context, { threadId, native: true, offsets: args.section ? { [args.section]: args.offset } : undefined,
             host: { tools: options.tools(), child: !!options.threadId } });
         return { content: [{ type: 'text', text: JSON.stringify(result) }] };

package/dist/mcp-server.js

@@ -56,6 +56,8 @@ const leases_1 = require("./leases");
 const hitl_gates_1 = require("./hitl-gates");
 const hitl_contract_1 = require("./hitl-contract");
 const hitl_presentation_1 = require("./hitl-presentation");
+const roadmap_status_1 = require("./roadmap-status");
+const network_roadmap_1 = require("./network-roadmap");
 const hitl_sessions_1 = require("./hitl-sessions");
 const hitl_local_1 = require("./hitl-local");
 const mcp_artifacts_1 = require("./mcp-artifacts");
@@ -65,6 +67,7 @@ const modos_1 = require("./modos");
 const versao_1 = require("./versao");
 const mcp_verify_1 = require("./mcp-verify");
 const conducao_1 = require("./conducao");
+const decisao_autonoma_1 = require("./decisao-autonoma");
 const conducao_texto_1 = require("./conducao-texto");
 const mcp_ship_1 = require("./mcp-ship");
 const company_brain_mcp_1 = require("./company-brain-mcp");
@@ -72,6 +75,8 @@ const claude_bg_1 = require("./adapters/claude-bg");
 const session_watcher_claude_1 = require("./session-watcher-claude");
 const runtime_profiles_1 = require("./runtime-profiles");
 const mcp_maestro_1 = require("./mcp-maestro");
+const projeto_alvo_1 = require("./projeto-alvo");
+const mcp_experiencia_1 = require("./mcp-experiencia");
 const identidade = zod_1.z.string().min(1).max(80).regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/);
 const daThread = zod_1.z.object({ threadId: identidade }).strict();
 const daDecisao = daThread.extend({ pedidoId: identidade }).strict();
@@ -297,15 +302,33 @@ function criarServidorMcp(opcoes) {
                 throw Error('lease.busy: ' + conflitos.map(l => l.nome + ' (' + l.thread + ')').join(', '));
         }
     };
-    const server = new index_js_1.Server({ name: 'orkastery', version: versao_1.VERSAO_DO_ORK }, { capabilities: { tools: {} }, instructions: 'Opere somente este projeto pelas ferramentas do nucleo. Decisoes humanas usam ork_request_decision e o dialogo do host; argumentos de ferramenta nunca sao respostas.' });
+    const server = new index_js_1.Server({ name: 'orkastery', version: versao_1.VERSAO_DO_ORK }, { capabilities: { tools: {} }, instructions: 'Opere somente este projeto pelas ferramentas do nucleo. O parametro opcional projeto so confere o projeto servido; nunca troca a raiz. O status do roadmap vem de ork_network_roadmap, transportado como vem. Decisoes humanas usam ork_request_decision e o dialogo do host; argumentos de ferramenta nunca sao respostas.' });
+    /**
+     * RM-052 (D5): toda tool aceita `projeto`, e ele so CONFERE o projeto fixado no startup. Pedido de
+     * outro projeto recusa tipado, com o projeto servido como unico candidato; a raiz nunca muda aqui.
+     */
+    const conferirProjeto = (pedido) => {
+        const c = carregar(), nome = c.manifesto.project.name, abbrev = c.manifesto.project.abbrev, v = pedido.toLowerCase();
+        if (nome.toLowerCase() === v || (!!abbrev && abbrev.toLowerCase() === v))
+            return;
+        throw new projeto_alvo_1.ErroDeProjeto('projeto.fora-do-servidor', `este servidor MCP atende somente o projeto ${nome}; "${pedido}" nao e ele`, [{ nome, abbrev, raiz: (0, projeto_alvo_1.raizParaExibir)(raiz), remoto: (0, projeto_alvo_1.remotoDoProjeto)(raiz, c.manifesto.fabrica?.remoto ?? 'origin'), presente: true }], 'Use o servidor MCP instalado no outro projeto (ork mcp install --project <raiz>), ou o CLI com --projeto <nome>.');
+    };
+    const campoProjeto = zod_1.z.string().regex(projeto_alvo_1.PADRAO_DO_NOME_DE_PROJETO)
+        .describe('Nome ou abbrev do projeto pedido; este servidor atende somente o projeto fixado na instalacao');
     const ferramentas = new Map();
     function registrarTool(nome, config, executar) {
         if (opcoes.threadId && ['ork_thread_new', 'ork_phase_run', 'ork_request_decision', 'ork_preflight'].includes(nome))
             return;
-        const schema = converterSchema(config.inputSchema, { $refStrategy: 'none' });
+        const entrada = config.inputSchema.extend({ projeto: campoProjeto.optional() });
+        const schema = converterSchema(entrada, { $refStrategy: 'none' });
         ferramentas.set(nome, { tool: { name: nome, description: config.description, annotations: config.annotations,
                 inputSchema: schema },
-            executar: async (raw, extra) => executar(config.inputSchema.parse(raw), extra) });
+            executar: async (raw, extra) => {
+                const { projeto, ...args } = entrada.parse(raw);
+                if (projeto !== undefined)
+                    conferirProjeto(projeto);
+                return executar(args, extra);
+            } });
     }
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools: [...ferramentas.values()].map(f => f.tool) }));
     server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request, extra) => {
@@ -316,6 +339,8 @@ function criarServidorMcp(opcoes) {
             return await f.executar(request.params.arguments ?? {}, extra);
         }
         catch (e) {
+            if (e instanceof projeto_alvo_1.ErroDeProjeto)
+                return { ...resposta(e.recusa), isError: true };
             return { ...resposta({ erro: e.message }), isError: true };
         }
     });
@@ -344,6 +369,7 @@ function criarServidorMcp(opcoes) {
     });
     server.onclose = () => ingresso.fechar();
     (0, company_brain_mcp_1.registerBrainTools)(registrarTool, carregar, thread, opcoes.brainWrites ?? []);
+    (0, mcp_experiencia_1.registrarConsultasExperiencia)(registrarTool, { raiz, carregar, transporte: opcoes.transporteShip ?? 'github-ssh' });
     (0, mcp_maestro_1.registerMaestro)(registrarTool, { root: raiz, threadId: opcoes.threadId, load: carregar, checkThread: thread, tools: () => [...ferramentas.keys()] });
     registrarTool('ork_preflight', { description: 'Preflight contextual por modo e bloco, sem inventário global/modelos. Não autoriza despacho nem comprova entrega.',
         inputSchema: zod_1.z.object({ modo: modoDeConducao }).strict(), annotations: { readOnlyHint: true } }, async ({ modo }) => {
@@ -402,6 +428,35 @@ function criarServidorMcp(opcoes) {
         livre(threadId);
         return resposta((0, mcp_artifacts_1.escreverArtefatoMcp)(raiz, threadId, tipo, conteudo, expectedSha256));
     });
+    // RM-037 (rm037defeito, defeito 1): a decisao que a sessao toma sem perguntar ao dono. O sandbox do
+    // codex nao grava o ledger e o `ork decisao registrar` morria em EROFS. Mesma `registrarDecisao` do CLI:
+    // contrato v2, criterio que resolve e rastro no mesmo evento. Nao pergunta ao dono e nao toca gate.
+    const campoDaDecisao = zod_1.z.string().min(1).max(4096);
+    registrarTool('ork_decision_record', { description: 'Registra decisao ja tomada pela sessao sem perguntar ao dono (classe decidido), com criterio que resolve e rastro. Nao pergunta, nao responde nem aprova gate.',
+        inputSchema: daThread.extend({ decidido: campoDaDecisao, porque: campoDaDecisao, comoMudar: campoDaDecisao,
+            custoAgora: campoDaDecisao, custoDepois: campoDaDecisao,
+            criterio: zod_1.z.object({ tipo: zod_1.z.enum(['manifesto', 'ledger', 'medicao']), referencia: campoDaDecisao }).strict(),
+            quemDecidiu: zod_1.z.string().min(1).max(200), evidencia: campoDaDecisao, razao: campoDaDecisao.optional(),
+            reverte: zod_1.z.string().min(1).max(80).optional() }).strict(),
+        annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ threadId, ...e }) => {
+        thread(threadId);
+        livre(threadId);
+        // A sessao decide por ela: o rastro nao pode nascer assinado em nome do dono.
+        if (/^\s*(?:o\s+|a\s+)?(?:dono|owner|builder|maestro)\b/i.test(e.quemDecidiu))
+            throw Error('mcp.decision.author: quemDecidiu e a sessao que decidiu, nunca o dono');
+        let registro;
+        try {
+            registro = (0, decisao_autonoma_1.registrarDecisao)(raiz, threadId, { decidido: e.decidido, porque: e.porque, comoMudar: e.comoMudar,
+                custoDeReverter: { agora: e.custoAgora, depois: e.custoDepois }, criterio: e.criterio, quemDecidiu: e.quemDecidiu,
+                evidencia: e.evidencia, ...(e.razao ? { razao: e.razao } : {}), ...(e.reverte ? { reverte: e.reverte } : {}), origem: 'mcp', host: opcoes.host,
+                despacho: opcoes.dispatchId ?? null });
+        }
+        catch (erro) {
+            throw Error((0, hitl_contract_1.recusaNaSuperficie)(erro.message, hitl_contract_1.CAMPOS_DA_DECISAO_NO_MCP));
+        }
+        const { pedido, evento } = registro;
+        return resposta({ ok: true, pedidoId: pedido.id, eventId: evento.eventId, fase: pedido.fase, reciboOficial: false });
+    });
     registrarTool('ork_claims_list', { description: 'Lista alegacoes e seu estado de verificacao registrado pelo nucleo.',
         inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => {
         thread(threadId);
@@ -423,6 +478,25 @@ function criarServidorMcp(opcoes) {
     });
     registrarTool('ork_hitl_pending', { description: 'Pedidos HITL atuais da thread, incluindo prazo; nao aprova nem abre pedido.',
         inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => resposta({ threadId, pendencias: pendencias(threadId) }));
+    registrarTool('ork_roadmap_status', { description: 'Status report do roadmap SO desta maquina (o checkout local), no formato aprovado pelo dono: grupos com icones, #HITL no que espera o dono e o fecho. Somente leitura; transporte o texto como vem. O cabecalho diz o projeto consultado e o que nao foi lido (reservas, outras maquinas). Para o status do roadmap com as threads de todas as maquinas, as reservas, as fontes e as lacunas, use ork_network_roadmap; nunca conclua sobre ele a partir de ork_maestro ou de threads.',
+        inputSchema: zod_1.z.object({}).strict(), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false } }, async () => {
+        const c = carregar();
+        // RM-052: origem `instalacao`; o servidor fixado nao revela os outros projetos da maquina.
+        const consulta = (0, projeto_alvo_1.consultaDoProjeto)(c, { origem: 'instalacao', outrosProjetos: false,
+            lido: ['roadmap (docs/roadmap)', projeto_alvo_1.FORA_DA_CONSULTA.threadsDaMaquina], naoLido: [projeto_alvo_1.FORA_DA_CONSULTA.reservas, 'threads de outras máquinas (ork network roadmap)'] });
+        const status = (0, roadmap_status_1.montarStatusDoRoadmap)(raiz, { projeto: c.manifesto.project.name, consulta });
+        return resposta({ texto: (0, roadmap_status_1.textoDoStatusDoRoadmap)(status), status });
+    });
+    /**
+     * RM-054 (fatia 2, D-G5): o roadmap da rede do projeto servido, em todas as maquinas dele. O servidor
+     * fixado nao le o registro nem revela os outros projetos (D5 da RM-052); o texto e o do CLI.
+     */
+    registrarTool('ork_network_roadmap', { description: 'Roadmap da rede do projeto servido, somente leitura: o status report do roadmap (RM-048) com as threads de TODAS as maquinas, as reservas, as threads por maquina com a idade da batida, a fonte e a hora de cada parte e as lacunas tipadas. E a fonte do status do roadmap: transporte o texto como vem, sem reescrever nem resumir. Lacuna e "Nao consultado" sao o que nao foi lido: nunca conclua "roadmap vazio" nem "nenhuma maquina publicou" a partir deles. Este servidor le so o projeto fixado; os outros projetos vem do CLI ork network roadmap.',
+        inputSchema: zod_1.z.object({}).strict(), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true } }, async () => {
+        carregar();
+        const panorama = (0, network_roadmap_1.montarPanoramaDaRede)({ fixado: raiz });
+        return resposta({ texto: (0, network_roadmap_1.textoDoPanoramaDaRede)(panorama), panorama });
+    });
     registrarTool('ork_observe', { description: 'Observa uma vez o progresso canonico e pedidos da thread. Nao cria monitor ou despacho.',
         inputSchema: daThread, annotations: { readOnlyHint: true } }, async ({ threadId }) => {
         return resposta(observar(threadId));
@@ -439,14 +513,19 @@ function criarServidorMcp(opcoes) {
         while (!fs.existsSync(existente))
             existente = path.dirname(existente);
         confinado(existente);
-        return resposta((0, thread_1.novaThread)(c, { nome, modo: modo ?? c.manifesto.conduction.default_mode, criarWorktree: true }));
+        const criada = (0, thread_1.novaThread)(c, { nome, modo: modo ?? c.manifesto.conduction.default_mode, criarWorktree: true });
+        // RM-052 (D7): thread nova, projeto conhecido pelo nome nesta maquina; o registro nunca derruba a criacao.
+        if (criada.gravada)
+            (0, projeto_alvo_1.registrarProjetoEmSilencio)(raiz, 'mcp thread new');
+        return resposta(criada);
     });
     registrarTool('ork_phase_run', { description: 'Despacha fase autorizada pelo nucleo, preservando policies, estado e runtime/modelo. dryRun nao inicia modelo, mas pode registrar prompt/eventos.',
         inputSchema: fase, annotations: { readOnlyHint: false, destructiveHint: false } }, async (args) => {
         const t = thread(args.threadId);
         livre(t.id);
         const { threadId, fase: f, ...op } = args;
-        return resposta((0, phase_1.rodarFase)(carregar(), threadId, { ...op, fase: (0, thread_1.exigirFase)(t, f), canal: conducao.canal }));
+        // RM-037 (A3): o MCP nao roda a suite para a baseline do despacho; a falta dela volta como pendencia.
+        return resposta((0, phase_1.rodarFase)(carregar(), threadId, { ...op, fase: (0, thread_1.exigirFase)(t, f), canal: conducao.canal, baselinePeloDespacho: false }));
     });
     registrarTool('ork_gate_request', { description: 'Abre pedido de gate somente quando pausa ou escalacao tipada esta comprovada no nucleo; nao aprova.',
         inputSchema: daThread.extend({ motivo: zod_1.z.enum(['human.pending', 'policy.violation', 'cost.violation',