@orkastery/cli 0.4.2 → 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

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOOKS_ESTRITOS = exports.HOOKS_DO_COMMIT = exports.HOOKS_INERTES_DO_COMMIT = void 0;
 exports.estadoGitMcp = estadoGitMcp;
 exports.commitMcp = commitMcp;
 exports.perfilGitMcp = perfil;
@@ -41,8 +42,8 @@ exports.caminhoFisicoGitMcp = fisico;
 exports.metadadosGitMcp = arvoreMetadados;
 exports.configuracaoPassivaGitMcp = configPassiva;
 exports.ambienteGitMcp = ambiente;
-/** Commit estreito no núcleo instalado. Repositórios com hooks/helpers ficam
- * explicitamente indisponíveis; nenhum hook ou configuração é desativado. */
+/** Commit estreito no núcleo instalado. Repositórios com hooks/helpers que as operações
+ * executariam ficam explicitamente indisponíveis; nenhum hook ou configuração é desativado. */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
@@ -130,6 +131,14 @@ 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))
+        return valor.length <= 512 && !/[\x00-\x1f\x7f]/.test(valor);
     if (['core.filemode', 'core.logallrefupdates', 'core.ignorecase', 'core.precomposeunicode'].includes(chave))
         return /^(true|false)$/.test(valor);
     if (chave === 'core.repositoryformatversion')
@@ -195,7 +204,22 @@ function atributosPassivos(wt, id, selecionados) {
     }
     return resultados.join('\0');
 }
-function perfil(wt, comum, gitdir, id, selecionados) {
+/**
+ * RM-037 (defeitosdeco D-3): hooks que os comandos Git do status e do commit (`config`, `ls-files`,
+ * `check-attr`, `rev-parse`, `symbolic-ref`, `diff`, `diff-tree`, `add` e `commit` sem `--amend`)
+ * nunca invocam. Lista positiva: nome fora dela (`pre-commit`, `commit-msg`, `reference-transaction`,
+ * `post-index-change`, nome que o Git criar amanhã) continua recusado, e nada é desativado.
+ */
+exports.HOOKS_INERTES_DO_COMMIT = new Set(['pre-push', 'pre-rebase', 'post-checkout', 'post-merge',
+    'pre-receive', 'update', 'proc-receive', 'post-receive', 'post-update', 'push-to-checkout', 'applypatch-msg',
+    'pre-applypatch', 'post-applypatch', 'sendemail-validate', 'pre-merge-commit', 'post-rewrite',
+    'p4-changelist', 'p4-prepare-changelist', 'p4-post-changelist', 'p4-pre-submit']);
+exports.HOOKS_DO_COMMIT = { inertes: exports.HOOKS_INERTES_DO_COMMIT,
+    correcao: 'o commit do MCP o executaria; commite pelo shell da worktree, onde o hook roda como sempre' };
+/** Padrão estrito (SHIP): merge e push executariam qualquer hook, inclusive o pre-push. */
+exports.HOOKS_ESTRITOS = { inertes: new Set(),
+    correcao: 'o SHIP do MCP o executaria (merge ou push); entregue por PR com o bundle do ork ci prepare, ou pelo ork ship do CLI' };
+function perfil(wt, comum, gitdir, id, selecionados, hooksDaOperacao = exports.HOOKS_ESTRITOS) {
     fisico(path.dirname(comum), comum);
     fisico(comum, gitdir);
     for (const nome of ['objects', 'refs', 'logs', 'info'])
@@ -224,9 +248,11 @@ function perfil(wt, comum, gitdir, id, selecionados) {
         if (fs.lstatSync(hooks, { throwIfNoEntry: false })) {
             fisico(base, hooks);
             for (const nome of fs.readdirSync(hooks)) {
-                const f = path.join(hooks, nome), s = fs.lstatSync(f);
-                if (!s.isFile() || s.isSymbolicLink() || (!nome.endsWith('.sample') && (s.mode & 0o111) !== 0))
-                    falha('execution-profile.unsupported: hooks preservados');
+                const f = path.join(hooks, nome), s = fs.lstatSync(f), rotulo = nome.replace(/[^A-Za-z0-9._-]/g, '?').slice(0, 64);
+                if (!s.isFile() || s.isSymbolicLink())
+                    falha(`execution-profile.unsupported: hooks preservados (${rotulo} nao e arquivo regular)`);
+                if (!nome.endsWith('.sample') && (s.mode & 0o111) !== 0 && !hooksDaOperacao.inertes.has(nome))
+                    falha(`execution-profile.unsupported: hooks preservados (${rotulo}); ${hooksDaOperacao.correcao}`);
             }
         }
     }
@@ -259,7 +285,7 @@ function estadoGitMcp(raiz, threadId) {
     if (!match)
         falha('worktree.invalid');
     const comum = path.join(raiz, '.git'), gitdir = path.resolve(wt, match[1].trim());
-    perfil(wt, comum, gitdir, t.id, []);
+    perfil(wt, comum, gitdir, t.id, [], exports.HOOKS_DO_COMMIT);
     if ((0, estado_thread_1.raizDoEstado)(wt) !== raiz)
         falha('worktree.invalid');
     const branch = (0, worktree_1.branchDaWorktree)(t), destino = c.manifesto.worktree.base_branch;
@@ -300,10 +326,10 @@ function executar(raiz, p) {
         fisico(comum, gitdir);
         if ((0, estado_thread_1.raizDoEstado)(wt) !== raiz)
             falha('worktree.invalid');
-        const originalPerfil = perfil(wt, comum, gitdir, t.id, p.paths);
+        const originalPerfil = perfil(wt, comum, gitdir, t.id, p.paths, exports.HOOKS_DO_COMMIT);
         const conferir = () => {
             (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, t.id);
-            if (perfil(wt, comum, gitdir, t.id, p.paths) !== originalPerfil)
+            if (perfil(wt, comum, gitdir, t.id, p.paths, exports.HOOKS_DO_COMMIT) !== originalPerfil)
                 falha('execution-profile.changed');
             if (git(wt, ['rev-parse', 'HEAD']).trim() !== p.expectedHead)
                 falha('head.stale');
@@ -344,7 +370,7 @@ function executar(raiz, p) {
             git(wt, ['commit', '-m', p.mensagem, '--', ...p.paths]);
             commit = git(wt, ['rev-parse', 'HEAD']).trim();
         });
-        if (perfil(wt, comum, gitdir, t.id, p.paths) !== originalPerfil)
+        if (perfil(wt, comum, gitdir, t.id, p.paths, exports.HOOKS_DO_COMMIT) !== originalPerfil)
             falha('execution-profile.changed');
         estadoAuditado = (0, estado_thread_1.auditarEstado)(raiz, t.id, wt).nivel === 'ok';
         if (!estadoAuditado)

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) }] };