@orkastery/cli 0.5.6 → 0.6.0

package/dist/maquina-ociosa.js

@@ -0,0 +1,211 @@
+"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.maquinaOciosa = maquinaOciosa;
+/**
+ * RM-063 (F6): ociosidade e alerta.
+ *
+ * Pedido do dono de 12/10/2026: "Você não pode deixar a máquina parada sem me avisar." No maquina-b, de 03 a 12/10, a
+ * maquina ficou dias sem sessao viva com item do roadmap reservado para ela, e nenhum canal disse nada. Aqui mora a
+ * leitura que faz disso um alerta: a maquina esta ociosa quando o projeto tem vaga livre (as vagas ocupadas, pela mesma
+ * regra do portao de vaga do despacho, abaixo de `concurrency.max_parallel_threads`) e ha trabalho reservado para ela no
+ * roadmap (`ork/roadmap-reservas`) que ninguem trabalha agora. O alerta leva as proximas threads sugeridas, ate o numero
+ * de vagas livres, cada uma com o passo do condutor do nucleo e o comando.
+ *
+ * Leitura pura: as reservas vem da ultima copia local da branch de reservas (sem rede), e quem dedupe o alerta por
+ * episodio e a varredura (`pulse-delivery`).
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const board_1 = require("./board");
+const conducao_1 = require("./conducao");
+const conducao_sentinela_1 = require("./conducao-sentinela");
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+const locale_1 = require("./locale");
+const maquina_1 = require("./maquina");
+const noctum_guarda_1 = require("./noctum-guarda");
+const parado_no_condutor_1 = require("./parado-no-condutor");
+const roadmap_reservas_1 = require("./roadmap-reservas");
+const thread_1 = require("./thread");
+const ITEM = /^RM-\d{3}$/;
+/** O titulo do item, do frontmatter da pagina dele em `docs/roadmap/` (`null` sem a pagina). */
+function tituloDoItem(raiz, item) {
+    const dir = path.join(raiz, 'docs', 'roadmap');
+    let arquivo;
+    try {
+        arquivo = fs.readdirSync(dir).find((f) => f.startsWith(`${item}-`) && f.endsWith('.md'));
+    }
+    catch {
+        return null;
+    }
+    if (!arquivo)
+        return null;
+    let texto;
+    try {
+        texto = fs.readFileSync(path.join(dir, arquivo), 'utf8').slice(0, 8192);
+    }
+    catch {
+        return null;
+    }
+    const m = /^titulo:\s*(.+)$/m.exec(texto);
+    return m ? m[1].trim().replace(/^["']|["']$/g, '').replace(/\p{Cc}/gu, ' ').slice(0, 120) || null : null;
+}
+/** A thread que trabalha o item: a da reserva, quando existe aqui; senao a aberta mais recente do item. */
+function threadDoItem(threads, r) {
+    const daReserva = r.thread ? threads.find((t) => t.id === r.thread) ?? null : null;
+    if (daReserva)
+        return daReserva;
+    return threads.filter((t) => t.roadmap === r.item && t.status !== 'fechada')
+        .sort((a, b) => String(b.atualizadaEm ?? '').localeCompare(String(a.atualizadaEm ?? '')))[0] ?? null;
+}
+/** O passo do condutor de uma thread parada, como a sugestao o diz, com o comando. */
+function passoDaSugestao(t, passo) {
+    if (passo?.acao === 'despachar' && passo.fase) {
+        const fase = passo.fase;
+        return { passo: (0, locale_1.textoDoCatalogo)((m) => m.pulse.ociosa.despachar(fase)),
+            comando: `ork phase run ${t.id} ${fase} --prompt "$(ork prompt render ${t.id} ${fase})"` };
+    }
+    if (passo?.acao === 'retomar')
+        return { passo: (0, locale_1.textoDoCatalogo)((m) => m.pulse.ociosa.retomar), comando: `ork retry run ${t.id}` };
+    if (passo?.acao === 'avisar' && passo.proximoPasso) {
+        const proximo = passo.proximoPasso;
+        return { passo: proximo, comando: `ork thread status ${t.id}` };
+    }
+    return { passo: (0, locale_1.textoDoCatalogo)((m) => m.pulse.ociosa.verAThread(t.faseAtual)), comando: `ork thread status ${t.id}` };
+}
+/**
+ * A maquina esta ociosa? `null` quando nao esta: sem vaga livre, ou sem trabalho reservado para ela que ninguem
+ * trabalha agora. Fica de fora do trabalho reservado o item cuja thread esta fechada (a reserva e orfa), cuja thread
+ * alguem conduz agora e cuja thread espera o dono (o passo e dele, e a fila do dono ja o mostra).
+ */
+function maquinaOciosa(carregado, opcoes = {}) {
+    const raiz = (0, estado_thread_1.raizDoEstado)(carregado.raiz);
+    const doProjeto = { ...carregado, raiz };
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const maquina = opcoes.maquina ?? (0, maquina_1.nomeDaMaquina)();
+    const limite = Math.max(1, carregado.manifesto.concurrency.max_parallel_threads);
+    const ocupadas = opcoes.ocupadas ? opcoes.ocupadas() : (0, board_1.sessoesQueOcupam)(doProjeto, { quando }).length;
+    if (ocupadas >= limite)
+        return null;
+    const remoto = carregado.manifesto.fabrica.remoto;
+    const reservas = (opcoes.reservas ? opcoes.reservas() : (0, roadmap_reservas_1.reservasLocais)(raiz, remoto))
+        .filter((r) => r.maquina === maquina && ITEM.test(r.item));
+    if (!reservas.length)
+        return null;
+    const threads = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            threads.push((0, thread_1.lerThread)(raiz, id));
+        }
+        catch { /* thread ilegivel fica de fora */ }
+    }
+    // RM-058, integracao (T1.2): o trabalho de um arco #Noctum nao e sugerido. A thread que o arco segura ou retem fica com
+    // ele, e o item da lista de um arco que guarda (sem thread aberta ainda) e o arco que abre.
+    const arcos = (0, noctum_guarda_1.lerArcosDaRaiz)(raiz, quando);
+    const itensDosArcos = new Set();
+    for (const { estado, proposta } of arcos.lidos.values()) {
+        const guarda = (0, noctum_guarda_1.guardaOsCaminhosManuais)({ arco: estado.arco, situacao: estado.situacao, origem: 'envelope' });
+        for (const w of guarda ? estado.conteudo?.trabalhos ?? [] : [])
+            itensDosArcos.add(w.item);
+        for (const w of estado.situacao === 'proposto' || guarda ? proposta?.trabalhos ?? [] : [])
+            itensDosArcos.add(w.item);
+    }
+    const paradas = [];
+    for (const r of reservas) {
+        const t = threadDoItem(threads, r);
+        if (t?.status === 'fechada')
+            continue;
+        if (!t && itensDosArcos.has(r.item))
+            continue;
+        if (t) {
+            let conduzida = true;
+            try {
+                conduzida = (0, conducao_1.conducaoDaThread)(raiz, t.id, { agora: new Date(quando) }) !== null;
+            }
+            catch {
+                conduzida = true;
+            }
+            if (conduzida)
+                continue;
+            let eventos = [];
+            try {
+                eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id));
+            }
+            catch {
+                eventos = [];
+            }
+            let doDono = null;
+            try {
+                doDono = (0, parado_no_condutor_1.pendenciaDoDono)(t, eventos, quando);
+            }
+            catch {
+                doDono = null;
+            }
+            if (doDono)
+                continue;
+            if ((0, noctum_guarda_1.arcoDoPasso)(raiz, arcos, t.id, eventos))
+                continue;
+        }
+        paradas.push({ r, t });
+    }
+    if (!paradas.length)
+        return null;
+    // A thread que ja existe vem antes (retomar custa menos que abrir), e a reserva mais antiga primeiro.
+    paradas.sort((a, b) => Number(!a.t) - Number(!b.t) || a.r.desdeEm.localeCompare(b.r.desdeEm) || a.r.item.localeCompare(b.r.item));
+    const livres = limite - ocupadas;
+    const escolhidas = paradas.slice(0, livres);
+    let passos = [];
+    if (escolhidas.some((x) => x.t)) {
+        try {
+            passos = opcoes.passos ? opcoes.passos() : (0, conducao_sentinela_1.passosDoCondutor)(doProjeto, { quando });
+        }
+        catch {
+            passos = [];
+        }
+    }
+    const sugeridas = escolhidas.map(({ r, t }) => {
+        const titulo = tituloDoItem(raiz, r.item);
+        if (!t) {
+            const nome = (titulo ?? r.item).replace(/"/g, "'");
+            return { item: r.item, titulo, thread: null, fase: null, passo: (0, locale_1.textoDoCatalogo)((m) => m.pulse.ociosa.abrir),
+                comando: `ork thread new "${nome}" --modo auto --roadmap ${r.item}` };
+        }
+        const { passo, comando } = passoDaSugestao(t, passos.find((p) => p.thread === t.id));
+        return { item: r.item, titulo, thread: t.id, fase: t.faseAtual, passo, comando };
+    });
+    return { maquina, limite, ocupadas, livres, reservados: paradas.length, sugeridas,
+        fonte: `copia local de ${remoto}/ork/roadmap-reservas` };
+}

package/dist/maquina.js

@@ -59,11 +59,17 @@ exports.avisoDaFabricaPedida = avisoDaFabricaPedida;
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
+const locale_1 = require("./locale");
 exports.CONTRATO_CONFIG_DA_MAQUINA = 'ork.maquina/v1';
 const ARQUIVO = 'maquina.json';
-/** A pasta do usuario (`~/.orkastery`). `ORK_USUARIO_DIR` isola testes e `ork eval`. */
-function pastaDoUsuario() {
-    return (process.env.ORK_USUARIO_DIR ?? '').trim() || path.join(os.homedir(), '.orkastery');
+/**
+ * A pasta do usuario (`~/.orkastery`). `ORK_USUARIO_DIR` isola testes e `ork eval`; `ORKASTERY_HOME` e a casa do ork
+ * que o registro das sessoes (`hitl-estado.ts`) ja seguia. RM-063 (fatia 3, achado b): a suite inteira roda com
+ * `ORKASTERY_HOME` temporario, e o registro de projetos, a maquina e a rede passam a segui-lo tambem.
+ */
+function pastaDoUsuario(env = process.env) {
+    return (env.ORK_USUARIO_DIR ?? '').trim() || (env.ORKASTERY_HOME ?? '').trim() ||
+        path.join(os.homedir(), '.orkastery');
 }
 function lerConfigDaMaquina() {
     try {
@@ -116,6 +122,5 @@ function fabricaCompartilhada(manifesto) {
 function avisoDaFabricaPedida(manifesto) {
     if (manifesto.fabrica?.compartilhada !== true || fabricaCompartilhada(manifesto))
         return null;
-    return 'fabrica.nao-confirmada: o orkastery.yaml pede fabrica.compartilhada: true, mas quem liga a publicacao ' +
-        'do retrato desta maquina e a propria maquina, nao o repositorio. Nada foi publicado. Para entrar: ork fabrica entrar';
+    return (0, locale_1.msg)().operacao.restante.fabrica.pedida;
 }

package/dist/master-nota-local.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESPERA_DA_TRAVA_MS = exports.PRAZO_DO_DIALOGO_MS = exports.PORQUE_MAXIMO = exports.PORQUE_MINIMO = exports.NOTAS_DO_FORMULARIO = exports.ERRO_SEM_DIALOGO = void 0;
+exports.esquemaDaNota = esquemaDaNota;
+exports.apresentarPedidoDaNota = apresentarPedidoDaNota;
+exports.lerRespostaDaNota = lerRespostaDaNota;
+exports.criarIngressoDaNota = criarIngressoDaNota;
+/**
+ * RM-059 (fatia F8, T8.1; DD2 do plano dos mods): a nota do MASTER pelo dialogo nativo do host.
+ *
+ * O caminho com prova da nota era o Telegram (`ork master pedir` + o codigo assinado pelo ingresso) e o terminal do
+ * dono. A sessao do Claude Code nao tinha como pedir a nota com recibo: o `--por` de processo de host e recusado por
+ * `exigirNotaSemHost`. Aqui a nota entra pelo MESMO ingresso local que o gate ja aceita: o servidor MCP pede ao
+ * cliente um formulario (elicitation), o dono escolhe de 0 a 5 e escreve o porque, e o nucleo grava o MASTER com
+ * `avaliadoPor` `dono (dialogo nativo)` (D12: uma identidade que o `autoriaHumana` de qualquer versao aceita), o host
+ * no `canal` e o recibo assinado em `hitl-ingress-local/`.
+ *
+ * Quem chama passa so o `threadId`. A nota e o porque nunca chegam por argumento de ferramenta: chegam pela resposta
+ * do formulario, que o callback do servidor recebe da propria conexao. O mod Ritual do MASTER (`ork-ritual`) so
+ * aperta o botao que chama a ferramenta.
+ *
+ * Ordem das conferencias (D4 da thread ork-rm059ritual): nota humana ja registrada devolve `repetida` sem dialogo;
+ * sem entrega, a recusa do nucleo; sem formulario no cliente, `master.nota.sem-dialogo` ANTES de qualquer escrita
+ * (nem o pedido de nota nasce); so entao o pedido de nota do `ork master pedir` (o mesmo codigo do Telegram) e o
+ * dialogo. A gravacao roda sob a trava da thread, como a resposta do Telegram (`responderNota`) e o aceite por omissao:
+ * a nota humana que chegou no meio, por qualquer caminho, vence, e a omissao nunca troca a nota gravada aqui. A trava
+ * ocupada e esperada por ate um minuto (D17), e a soltura do que a thread segurava roda depois dela.
+ *
+ * LIMITE DITO: o recibo prova o caminho (esta conexao MCP, esta solicitacao, esta nota), nao a pessoa. A chave local e
+ * legivel pelo mesmo usuario do sistema, entao quem ja roda como ele forja o recibo; e a mesma fronteira do gate pelo
+ * ingresso local (`core/src/hitl-local.ts`).
+ */
+const node_crypto_1 = require("node:crypto");
+const thread_1 = require("./thread");
+const hitl_gates_1 = require("./hitl-gates");
+const thread_close_1 = require("./thread-close");
+const claims_1 = require("./claims");
+const horario_1 = require("./horario");
+const master_1 = require("./master");
+const fechamento_1 = require("./fechamento");
+const master_nota_1 = require("./master-nota");
+const pulse_resposta_1 = require("./pulse-resposta");
+const hitl_local_receipt_1 = require("./hitl-local-receipt");
+exports.ERRO_SEM_DIALOGO = 'master.nota.sem-dialogo';
+/** As notas que o formulario oferece, da melhor para a pior. */
+exports.NOTAS_DO_FORMULARIO = ['5', '4', '3', '2', '1', '0'];
+exports.PORQUE_MINIMO = 3;
+exports.PORQUE_MAXIMO = 1000;
+/** O mesmo teto do dialogo do gate pelo ingresso local. */
+exports.PRAZO_DO_DIALOGO_MS = 300000;
+/**
+ * D17: com a nota respondida, a gravacao espera ate isto pela trava da thread (um aceite por omissao, uma resposta pelo
+ * Telegram ou um despacho a seguram por pouco), para o porque que o dono escreveu nao se perder num instante ocupado.
+ */
+exports.ESPERA_DA_TRAVA_MS = 60000;
+const PASSO_DA_TRAVA_MS = 250;
+const ID = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/;
+const sha = (v) => (0, node_crypto_1.createHash)('sha256').update(v).digest('hex');
+function esquemaDaNota() {
+    const rotulo = { '5': '5 · a melhor', '0': '0 · a pior' };
+    return {
+        type: 'object',
+        properties: {
+            nota: { type: 'string', title: 'Nota de 0 a 5', oneOf: exports.NOTAS_DO_FORMULARIO.map((n) => ({ const: n, title: rotulo[n] ?? n })) },
+            porque: { type: 'string', title: 'Por quê (vira lição do próximo GOAL)', minLength: exports.PORQUE_MINIMO, maxLength: exports.PORQUE_MAXIMO },
+        },
+        required: ['nota', 'porque'],
+    };
+}
+/** A mensagem do formulario: a entrega, o que vale agora, o indice derivado do ledger e as claims por estado. */
+function apresentarPedidoDaNota(raiz, threadId) {
+    const t = (0, thread_1.lerThread)(raiz, threadId);
+    const entrega = (0, thread_close_1.provaDeEntrega)(raiz, threadId);
+    const indice = (0, master_1.indiceDaThread)(raiz, threadId);
+    const ultimas = new Map();
+    for (const c of (0, claims_1.lerClaims)(raiz, threadId))
+        ultimas.set(c.id, c.estado);
+    const contar = (estado) => [...ultimas.values()].filter((e) => e === estado).length;
+    const parcelas = indice.parcelas.length
+        ? indice.parcelas.map((p) => `${p.evento} x${p.ocorrencias}`).join(', ')
+        : 'sem desconto';
+    const agora = t.score?.regime === 'omissao' ? `aceita por omissão com ${t.score.valor}/5`
+        : t.score_proposto ? `proposta de ${t.score_proposto.valor}/5 esperando você` : 'sem nota';
+    const quando = entrega?.tipo === 'ship'
+        ? `Entregue em ${(0, horario_1.formatarDataHoraRotulada)(entrega.ts)}${entrega.mergeSha ? ` (merge ${entrega.mergeSha.slice(0, 8)})` : ''}.`
+        : entrega ? `Entregue pelo artefato ${entrega.arquivo}.` : 'Sem entrega registrada.';
+    return {
+        thread: threadId,
+        mensagem: [
+            `Nota do MASTER da ${t.id} (${t.nome.slice(0, 80)})`,
+            `${quando} Agora: ${agora}.`,
+            `Índice derivado do ledger: ${indice.valor} de ${indice.base} (${parcelas}).`,
+            `Claims: ${contar('verificado')} verificadas, ${contar('reprovado')} reprovadas, ${contar('pendente')} pendentes.`,
+            'Dê de 0 a 5 e diga por quê. A sua nota sobrescreve a aceita por omissão.',
+        ].join('\n'),
+        esquema: esquemaDaNota(),
+    };
+}
+/** A resposta aceita, conferida campo a campo: so `nota` e `porque`, nos limites do formulario. */
+function lerRespostaDaNota(content) {
+    const c = content;
+    if (!c || typeof c !== 'object' || Array.isArray(c) || Object.keys(c).sort().join(',') !== 'nota,porque' ||
+        typeof c.nota !== 'string' || !exports.NOTAS_DO_FORMULARIO.includes(c.nota) ||
+        typeof c.porque !== 'string' || c.porque.trim().length < exports.PORQUE_MINIMO || c.porque.length > exports.PORQUE_MAXIMO) {
+        throw new Error('master.nota.resposta-invalida: a resposta do formulário não é uma nota de 0 a 5 com o porquê');
+    }
+    return { score: Number(c.nota), justificativa: c.porque.trim() };
+}
+/**
+ * O ingresso da nota numa conexao MCP. O `elicitar` e o `temFormulario` vem do servidor, nunca dos argumentos da
+ * ferramenta; o `connectionId` e o mesmo do ingresso local do gate nesta conexao.
+ */
+function criarIngressoDaNota(raiz, origem, elicitar, temFormulario, opcoes = {}) {
+    if (!['claude-code', 'codex'].includes(origem.host) || !ID.test(origem.connectionId))
+        throw new Error('master.nota.origem-invalida');
+    const conexao = { ...origem }, ativos = new Map();
+    let fechada = false;
+    const pendente = (threadId) => ({ ok: false, threadId, estado: 'pendente', repetida: false });
+    const esperaDaTrava = opcoes.esperaDaTravaMs ?? exports.ESPERA_DA_TRAVA_MS;
+    /** A trava da thread, esperada em passos curtos: ocupada alem da espera, a recusa diz que a nota nao foi gravada. */
+    const comTrava = async (threadId, executar) => {
+        const ate = Date.now() + esperaDaTrava;
+        for (;;) {
+            try {
+                return (0, hitl_gates_1.comLockHitl)(raiz, threadId, executar);
+            }
+            catch (e) {
+                if (!/^HITL ocupado/.test(e.message))
+                    throw e;
+                if (Date.now() >= ate) {
+                    throw new Error(`master.nota.trava-ocupada: a thread ${threadId} seguiu ocupada por ${Math.round(esperaDaTrava / 1000)} s; ` +
+                        'a nota não foi gravada, dê de novo');
+                }
+            }
+            await new Promise((r) => setTimeout(r, PASSO_DA_TRAVA_MS));
+        }
+    };
+    return {
+        fechar() { fechada = true; for (const c of ativos.values())
+            c.abort(); },
+        async solicitar(threadId, signal) {
+            if (fechada)
+                throw new Error('master.nota.conexao-fechada');
+            if (!ID.test(threadId))
+                throw new Error('master.nota.identificador-invalido');
+            if (signal?.aborted)
+                return pendente(threadId);
+            const t = (0, thread_1.lerThread)(raiz, threadId);
+            if ((0, master_1.notaHumanaRegistrada)(t))
+                return { ok: true, threadId, estado: 'registrada', repetida: true, score: t.score.valor };
+            (0, thread_close_1.exigirEntrega)(raiz, threadId);
+            if (!temFormulario()) {
+                throw new Error(`${exports.ERRO_SEM_DIALOGO}: este cliente MCP não abre formulário; peça a nota pelo Telegram com ork master pedir ${threadId}`);
+            }
+            if (ativos.has(threadId))
+                throw new Error('master.nota.em-curso: o diálogo da nota desta thread já está aberto nesta sessão');
+            const controller = new AbortController();
+            ativos.set(threadId, controller);
+            const abortar = () => controller.abort();
+            signal?.addEventListener('abort', abortar, { once: true });
+            const timer = setTimeout(abortar, exports.PRAZO_DO_DIALOGO_MS);
+            try {
+                const pedido = (0, master_nota_1.pedirNota)(raiz, threadId, { codigosEmUso: (0, pulse_resposta_1.codigosEmUso)(raiz) });
+                const apresentacao = apresentarPedidoDaNota(raiz, threadId);
+                const requestId = (0, node_crypto_1.randomUUID)();
+                const cancelar = new Promise((resolve) => controller.signal.addEventListener('abort', () => resolve({ action: 'cancel' }), { once: true }));
+                const resposta = await Promise.race([elicitar(apresentacao, controller.signal), cancelar]);
+                if (fechada || controller.signal.aborted || resposta?.action !== 'accept')
+                    return pendente(threadId);
+                const nota = lerRespostaDaNota(resposta.content);
+                const recebidoEm = new Date().toISOString();
+                const gravada = await comTrava(threadId, () => {
+                    const atual = (0, thread_1.lerThread)(raiz, threadId);
+                    if ((0, master_1.notaHumanaRegistrada)(atual))
+                        return { ok: true, threadId, estado: 'registrada', repetida: true, score: atual.score.valor };
+                    const recibo = (0, hitl_local_receipt_1.gravarEvidenciaLocalNota)(raiz, { thread: threadId, pedidoId: pedido.pedidoId, host: conexao.host,
+                        connectionId: conexao.connectionId, requestId, recebidoEm, score: nota.score, justificativaSha256: sha(nota.justificativa) });
+                    (0, master_1.gravarMaster)(raiz, threadId, {
+                        score: nota.score, justificativa: nota.justificativa, por: master_1.AUTOR_DA_NOTA_NATIVA, refazer: !!atual.score,
+                        prova: {
+                            origem: 'mcp-local', canal: conexao.host, contratoResposta: hitl_local_receipt_1.CONTRATO_RECIBO_DA_NOTA, conexao: conexao.connectionId,
+                            solicitacao: requestId, recebidoEm, recibo: recibo.recibo, evidencia: recibo.arquivo, evidenciaSha256: recibo.sha256,
+                            notaPedida: { contrato: master_nota_1.CONTRATO_PEDIDO_DE_NOTA, pedidoId: pedido.pedidoId, codigo: pedido.codigo },
+                        },
+                    });
+                    return { ok: true, threadId, estado: 'registrada', repetida: false, score: nota.score };
+                });
+                // D17: a thread fechada solta o que segurava depois da trava, como no `registrarMaster`.
+                if (!gravada.repetida)
+                    (0, fechamento_1.liberarAoFechar)(raiz, threadId);
+                return gravada;
+            }
+            finally {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', abortar);
+                ativos.delete(threadId);
+            }
+        },
+    };
+}

package/dist/master-nota.js

@@ -68,8 +68,16 @@ exports.mensagemJaUsadaEmNota = mensagemJaUsadaEmNota;
  *
  * 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.
+ * passa como terminal. Essa e a mesma fronteira do `humano-no-cli` do SHIP.
+ *
+ * RM-059 (fatia F8, T8.1): a sessao de host ganhou o caminho com recibo que faltava, o dialogo
+ * nativo (`ork_request_master_note`, em `master-nota-local.ts`): so o `threadId` entra pela
+ * ferramenta, a nota e o porque vem do formulario do host, e o MASTER grava `dono (dialogo nativo)`
+ * com o host no canal e o recibo assinado do ingresso local; essa identidade nao se digita no `--por`.
+ * O que fica: o `--por` do terminal continua sem prova, a recusa pelo ambiente continua sendo so
+ * recusa, e um `ork` anterior a esta versao aceita aquela identidade no `--por` como qualquer nome.
+ * O recibo local prova o caminho, nao a pessoa: quem ja
+ * roda como o mesmo usuario do sistema le a chave local e forja o recibo.
  */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));