@orkastery/cli 0.4.3 → 0.5.0

package/dist/company-brain-dossie.js

@@ -0,0 +1,376 @@
+"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.ID_DE_DECISAO = exports.DOSSIE_SCHEMA = void 0;
+exports.buildDossie = buildDossie;
+/**
+ * K3.1: dossiê de decisão. Só leitura: compõe o que o núcleo já grava (o ledger da thread, o objetivo
+ * do K1 e o escopo vinculado) com o pacote de contexto do Brain, sem registrar nada. Decidir continua
+ * sendo `ork decisao registrar` (decisão delegada) ou a resposta do dono pelo ingresso autenticado.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const company_brain_client_1 = require("./company-brain-client");
+const company_brain_contract_1 = require("./company-brain-contract");
+const company_brain_context_1 = require("./company-brain-context");
+const company_brain_source_1 = require("./company-brain-source");
+const decisao_autonoma_1 = require("./decisao-autonoma");
+const gates_1 = require("./gates");
+const hitl_contract_1 = require("./hitl-contract");
+const objective_1 = require("./objective");
+const portfolio_1 = require("./portfolio");
+const thread_1 = require("./thread");
+exports.DOSSIE_SCHEMA = 'ork.dossie-de-decisao/v1';
+/** O id que o dossiê aceita para uma decisão: o do pedido ou o que o Brain dá ao fato. */
+exports.ID_DE_DECISAO = /^(?:[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}|fact-[a-f0-9]{64})$/;
+/** Os mesmos números do pacote de contexto: lote da seleção e teto de `get` no caso misto. */
+const LIMITE = 1000;
+const LIMITE_DE_GET = 100;
+const comparar = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const falha = (state) => ['forbidden', 'unavailable', 'conflict'].includes(state);
+const texto = (v) => typeof v === 'string' ? v : null;
+/**
+ * D10: a mesma conferência do ramo `context` de `ork brain`, repetida aqui para não tocar aquele
+ * comando enquanto outra thread o muda. O escopo vale só se for desta thread e do formato do bind.
+ */
+function escopoVinculado(raiz, thread) {
+    const file = path.join((0, thread_1.dirThread)(raiz, thread), 'brain-scope.json');
+    if (!fs.existsSync(file))
+        return null;
+    let binding;
+    try {
+        binding = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw Error('brain.scope.invalid');
+    }
+    if (binding?.schema !== 'ork.brain-cycle-scope/v1' || binding.version !== 1 || binding.thread !== thread || typeof binding.projectId !== 'string' ||
+        !Array.isArray(binding.initiativeIds) || binding.initiativeIds.some((i) => typeof i !== 'string'))
+        throw Error('brain.scope.invalid');
+    return { projectId: binding.projectId, initiativeIds: binding.initiativeIds };
+}
+/**
+ * D3: o objetivo é o ticket do K1 (`creationOrigin.ticketId`) e, sem ele, o objetivo cuja lista de
+ * threads contém esta; o projeto é o escopo vinculado (o que a captura grava no `cycle`) e, sem ele, o
+ * `portfolio` do objetivo. Fonte faltando ou discordando vira lacuna, nunca escolha silenciosa.
+ */
+function vinculoDaThread(raiz, t, lacuna) {
+    let achado = null, semObjetivo = true;
+    const ticket = t.creationOrigin?.ticketId;
+    try {
+        if (ticket) {
+            const o = (0, objective_1.readObjective)(raiz, ticket);
+            if (!o.threads.some(x => x.id === t.id)) {
+                lacuna(t.id, 'vinculo.divergente');
+                semObjetivo = false;
+            }
+            else
+                achado = { o, origem: 'ticket' };
+        }
+        else {
+            const comEla = (0, objective_1.listObjectives)(raiz).filter(o => o.threads.some(x => x.id === t.id));
+            if (comEla.length > 1) {
+                lacuna(t.id, 'vinculo.divergente');
+                semObjetivo = false;
+            }
+            else if (comEla.length === 1)
+                achado = { o: comEla[0], origem: 'lista-de-threads' };
+        }
+    }
+    catch {
+        lacuna(ticket ?? t.id, 'objetivo.indisponivel');
+        semObjetivo = false;
+    }
+    if (!achado && semObjetivo)
+        lacuna(t.id, 'objetivo.ausente');
+    const escopo = escopoVinculado(raiz, t.id), doObjetivo = achado?.o.envelope.portfolio ?? null;
+    const ordenados = (ids) => [...new Set(ids)].sort(comparar);
+    let projeto = null;
+    if (escopo) {
+        const entidade = (0, portfolio_1.findEntity)(raiz, escopo.projectId);
+        projeto = { productId: entidade?.kind === 'project' ? entidade.productId : null, projectId: escopo.projectId,
+            initiativeIds: ordenados(escopo.initiativeIds), origem: 'escopo-vinculado' };
+        if (doObjetivo && (doObjetivo.projectId !== projeto.projectId ||
+            JSON.stringify(ordenados(doObjetivo.initiativeIds)) !== JSON.stringify(projeto.initiativeIds)))
+            lacuna(t.id, 'vinculo.divergente');
+    }
+    else if (doObjetivo) {
+        projeto = { productId: doObjetivo.productId, projectId: doObjetivo.projectId, initiativeIds: ordenados(doObjetivo.initiativeIds), origem: 'objetivo' };
+    }
+    else
+        lacuna(t.id, 'projeto.ausente');
+    // Título e estado ficam fora do envelope com hash: o que faltar sai vazio, nunca `undefined` no digest.
+    const objetivo = achado ? { id: achado.o.id, titulo: texto(achado.o.title) ?? '', estado: texto(achado.o.status) ?? '',
+        envelopeHash: achado.o.envelope.hash, origem: achado.origem } : null;
+    return { objetivo, projeto, brain: { thread_id: t.id, objective_id: objetivo?.id ?? null, project_id: projeto?.projectId ?? null,
+            initiative_ids: projeto?.initiativeIds ?? [] } };
+}
+/**
+ * Uma seleção por lote de ids `fact-…`; retido chega sem id, e só o caso misto pede `get`, como no contexto.
+ * Seleção que não responde `ok` nem `empty` fecha o dossiê: sem estado conhecido, nada local vira conteúdo.
+ */
+function consultarFatos(transport, tenant, ids) {
+    const ok = new Map(), retidos = new Set();
+    let gets = 0;
+    for (let inicio = 0; inicio < ids.length; inicio += LIMITE) {
+        const lote = ids.slice(inicio, inicio + LIMITE), doLote = new Set(lote);
+        const r = transport({ schema: company_brain_client_1.BRAIN_API, operation: 'query', payload: (0, company_brain_contract_1.validateContract)({ schema: 'orkmind.company-brain-selection/v1',
+                tenant_id: tenant, facets: { ids: lote, kinds: [], workspace_ids: [], source_instances: [] }, mode: 'selection', limit: lote.length, offset: 0 }) });
+        if (r.state !== 'ok' && r.state !== 'empty')
+            return r;
+        const itens = Array.isArray(r.items) ? r.items : [];
+        for (const item of itens)
+            if (item?.state === 'ok' && doLote.has(item.entity?.id))
+                ok.set(item.entity.id, item.entity);
+        const faltantes = lote.filter(id => !ok.has(id)), retidosNoLote = itens.filter((i) => i?.state === 'withheld').length;
+        if (retidosNoLote && retidosNoLote === faltantes.length)
+            faltantes.forEach(id => retidos.add(id));
+        else if (retidosNoLote)
+            for (const id of faltantes) {
+                if (++gets > LIMITE_DE_GET)
+                    return { schema: company_brain_client_1.BRAIN_API, state: 'unavailable', error: 'brain.dossie.get-limit' };
+                const g = transport({ schema: company_brain_client_1.BRAIN_API, operation: 'get', payload: { tenant_id: tenant, id } });
+                if (falha(g.state))
+                    return g;
+                if (g.state === 'withheld')
+                    retidos.add(id);
+                else if (g.state === 'ok' && g.entity?.id === id)
+                    ok.set(id, g.entity);
+            }
+    }
+    return { ok, retidos };
+}
+const TIPOS_DO_DOSSIE = new Set(['autonomous_decision', 'hitl_requested', 'human_gate', 'human_decision']);
+/**
+ * P2: o ledger é lido pela `readCycle`, a mesma leitura da captura. Uma linha que o contrato do Brain não
+ * representa (horário fora do formato, em ledgers antigos) derruba a leitura inteira; então a faixa que
+ * recusa é partida ao meio até isolar a linha, que fica sem id no Brain. Qualquer outro erro (linha
+ * corrompida, de outra thread) continua recusando o dossiê, como recusa a captura.
+ */
+function linhasDoLedger(bytes, scope) {
+    const brutas = bytes.subarray(0, bytes.lastIndexOf(10) + 1).toString('utf8').split('\n').slice(0, -1);
+    const inicios = [0];
+    for (const raw of brutas)
+        inicios.push(inicios[inicios.length - 1] + Buffer.byteLength(raw) + 1);
+    const linhas = [];
+    const faixa = (de, ate) => {
+        try {
+            (0, company_brain_source_1.readCycle)(bytes.subarray(0, inicios[ate]), scope, inicios[de]).records
+                .forEach((r, i) => linhas.push({ n: de + i + 1, e: JSON.parse(brutas[de + i]), evento: r.event }));
+        }
+        catch (erro) {
+            if (erro.message !== 'brain.contract.invalid')
+                throw erro;
+            if (ate - de === 1) {
+                linhas.push({ n: de + 1, e: JSON.parse(brutas[de]), evento: null });
+                return;
+            }
+            const meio = de + Math.floor((ate - de) / 2);
+            faixa(de, meio);
+            faixa(meio, ate);
+        }
+    };
+    if (brutas.length)
+        faixa(0, brutas.length);
+    return linhas.filter(l => TIPOS_DO_DOSSIE.has(l.e.tipo));
+}
+/**
+ * Monta o dossiê de uma thread ou de uma decisão dela. A fonte canônica da decisão é o ledger; o Brain
+ * é projeção, e a diferença entre os dois sai como frescor e lacuna. Item sem citação, resposta sem
+ * recibo conferido e decisão fora do contrato viram lacuna, nunca conteúdo.
+ */
+function buildDossie(c, thread, decisao, transport) {
+    // Filtro vazio é erro, não a thread inteira: quem pede uma decisão recebe essa ou a recusa.
+    if (decisao !== undefined && !exports.ID_DE_DECISAO.test(decisao))
+        throw Error('brain.dossie.decisao-invalida');
+    const filtro = decisao ?? null;
+    const t = (0, thread_1.lerThread)(c.raiz, thread), tenant = c.manifesto.memory.tenant;
+    const lacunas = [];
+    const lacuna = (id, codigo) => { lacunas.push({ id, codigo }); };
+    const vinculo = vinculoDaThread(c.raiz, t, lacuna);
+    const base = { schema: exports.DOSSIE_SCHEMA, tenant, contrato: company_brain_contract_1.CONTRACT_HASH, thread: t.id, decisao: filtro };
+    const encerrar = (r) => ({ ...base, state: r.state, ...(r.error ? { error: r.error } : {}),
+        vinculo, contexto: null, decisoes: [], lacunas: [], digest: null, consultadoEm: new Date().toISOString() });
+    const arquivo = path.join((0, thread_1.dirThread)(c.raiz, t.id), 'ledger.jsonl');
+    const bytes = fs.existsSync(arquivo) ? (0, company_brain_source_1.readSourceFile)(arquivo) : Buffer.alloc(0);
+    const linhas = linhasDoLedger(bytes, { tenant, instance: c.manifesto.project.name, thread: t.id, aclRef: 'ork-factory' });
+    // Cada linha é classificada uma vez, pelo validador do contrato; o que não valida é formato anterior.
+    const classe = new Map(), respostas = new Map(), revertidaPor = new Map();
+    const semIngresso = [];
+    const pedidoDe = (l) => l.e.pedido;
+    for (const l of linhas) {
+        const p = l.e.pedido;
+        if (l.e.tipo === 'autonomous_decision') {
+            let decidido = false;
+            try {
+                (0, hitl_contract_1.validarPedidoHitlV2)(p);
+                decidido = p.classe === 'decidido';
+            }
+            catch {
+                decidido = false;
+            }
+            classe.set(l, decidido ? 'decidido' : 'legado');
+            if (decidido && typeof l.e.reverte === 'string')
+                revertidaPor.set(l.e.reverte, l);
+        }
+        else if (l.e.tipo === 'hitl_requested') {
+            try {
+                (0, hitl_contract_1.validarPedidoHitl)(p);
+                if ((0, hitl_contract_1.alvoDoPedido)(p)?.tipo === 'gate')
+                    classe.set(l, 'pergunta');
+            }
+            catch { /* fora do contrato: não é pergunta */ }
+        }
+        else if (l.e.tipo === 'human_gate' && typeof l.e.pedidoId === 'string')
+            respostas.set(l.e.pedidoId, [...(respostas.get(l.e.pedidoId) ?? []), l]);
+        else if (l.e.tipo === 'human_decision')
+            semIngresso.push(l);
+    }
+    const candidatas = [...classe.keys()];
+    const referencia = (l) => `threads/${t.id}/ledger.jsonl#L${l.n}`;
+    const idDe = (l) => classe.get(l) !== 'legado' ? String(pedidoDe(l).id) : l.evento?.aggregate_id ?? referencia(l);
+    const escolhidas = filtro === null ? candidatas : candidatas.filter(l => idDe(l) === filtro || l.evento?.aggregate_id === filtro);
+    if (filtro !== null && !escolhidas.length)
+        lacuna(filtro, 'decisao.desconhecida');
+    // D8: `human_decision` é o relato de alguém sobre o dono, sem recibo: nunca vira decisão do dono.
+    if (filtro === null)
+        for (const l of semIngresso)
+            lacuna(referencia(l), 'decisao.humana-sem-ingresso');
+    // D4: a resposta só entra com o recibo reconferido pelas validadoras do núcleo, qualquer que seja o veredito.
+    const provadas = new Map();
+    for (const l of escolhidas)
+        if (classe.get(l) === 'pergunta') {
+            const gates = respostas.get(idDe(l)) ?? [];
+            if (gates.length === 1 && gates[0].evento && (0, gates_1.reciboHumanoConfere)(c.raiz, t.id, gates[0].e))
+                provadas.set(idDe(l), gates[0]);
+        }
+    let contexto = null;
+    if (vinculo.projeto) {
+        contexto = (0, company_brain_context_1.buildContext)(c, [vinculo.projeto.projectId, ...vinculo.projeto.initiativeIds], transport, t.id);
+        if (falha(contexto.state))
+            return encerrar(contexto);
+    }
+    // A decisão que desfaz outra também é conferida: a relação é conteúdo dela, e some se ela estiver retida.
+    const reversoras = escolhidas.flatMap(l => classe.get(l) === 'decidido' ? [revertidaPor.get(idDe(l))].filter((x) => !!x) : []);
+    const fatos = [...new Set([...escolhidas, ...provadas.values(), ...reversoras].flatMap(l => l.evento ? [l.evento.aggregate_id] : []))].sort(comparar);
+    let noBrain = { ok: new Map(), retidos: new Set() };
+    if (fatos.length) {
+        const r = consultarFatos(transport, tenant, fatos);
+        if ('state' in r)
+            return encerrar(r);
+        noBrain = r;
+    }
+    const ids = (evento) => ({ assertion_id: evento.aggregate_id, event_id: evento.id, source_event_id: evento.source_event_id });
+    const fato = (evento) => {
+        const id = evento.aggregate_id;
+        if (noBrain.retidos.has(id)) {
+            lacuna(id, 'brain.retido');
+            return { id, frescor: 'retido' };
+        }
+        const { instance, source_ref, source_hash, source_version, location } = evento.source, b = noBrain.ok.get(id);
+        const frescor = !b ? 'ausente-no-brain' : b.source?.source_hash === source_hash && b.source?.source_ref === source_ref ? 'confere' : 'divergente';
+        if (frescor === 'ausente-no-brain')
+            lacuna(id, 'brain.ausente');
+        if (frescor === 'divergente')
+            lacuna(id, 'fonte.divergente');
+        return { brain: ids(evento), citacao: { instance, source_ref, source_hash, source_version, location }, frescor };
+    };
+    const visivel = (l) => !!l?.evento && !noBrain.retidos.has(l.evento.aggregate_id);
+    const decisoes = [];
+    for (const l of escolhidas) {
+        // Sem id no Brain não há citação: a decisão vira lacuna, nunca conteúdo.
+        if (!l.evento) {
+            lacuna(idDe(l), 'citacao.incompleta');
+            continue;
+        }
+        const id = idDe(l), f = fato(l.evento), e = l.e, tipo = classe.get(l);
+        // D6: retido pelo Brain não mostra nem o conteúdo local (BR-024-03).
+        if (f.frescor === 'retido') {
+            decisoes.push(f);
+            continue;
+        }
+        const comum = { id, fase: texto(e.fase), em: e.ts, ...f };
+        if (tipo === 'decidido') {
+            const p = pedidoDe(l);
+            decisoes.push({ ...comum, classe: tipo, contrato: p.contrato, autoria: 'autonoma', decidido: p.decidido, porque: p.porque, comoMudar: p.comoMudar,
+                custoDeReverter: { agora: p.custoDeReverter.agora, depois: p.custoDeReverter.depois }, criterio: { tipo: p.criterio.tipo, referencia: p.criterio.referencia },
+                quemDecidiu: String(e.quemDecidiu ?? ''), evidencia: String(e.evidencia ?? ''), razao: String(e.razao ?? ''),
+                reverte: texto(e.reverte), revertidaPor: visivel(revertidaPor.get(p.id)) ? String(pedidoDe(revertidaPor.get(p.id)).id) : null });
+            // D-G3: o contrato do `decidido` não guarda alternativas; o `comoMudar` é o caminho de volta.
+            lacuna(id, 'alternativas.nao-registradas');
+        }
+        else if (tipo === 'pergunta') {
+            const p = pedidoDe(l);
+            const alternativas = p.contrato === 'ork.hitl/v2'
+                ? p.alternativas.map((a, i) => ({ numero: i + 1, letra: a.letra, texto: a.texto, acao: a.acao,
+                    consequencia: a.consequencia, recomendada: a.recomendada === true, porque: a.porque ?? null }))
+                : p.opcoes.map(o => ({ numero: o.numero, letra: null, texto: o.texto, acao: o.acao, consequencia: null, recomendada: false, porque: null }));
+            const provada = provadas.get(id), gates = respostas.get(id) ?? [];
+            let resposta = null, estado = 'aguardando';
+            if (provada) {
+                const r = fato(provada.evento), g = provada.e, escolha = alternativas.find(a => a.numero === g.opcao);
+                // Resposta retida: nem a escolha nem a autoria saem da linha local.
+                estado = r.frescor === 'retido' ? 'retida' : 'decidida';
+                resposta = r.frescor === 'retido' ? r : { ...r, opcao: Number.isInteger(g.opcao) ? g.opcao : null, letra: escolha?.letra ?? null,
+                    texto: escolha?.texto ?? null, veredito: texto(g.estado), quem: String(g.autorizadoPor ?? ''), origem: String(g.origem ?? ''),
+                    canal: texto(g.canal), recebidoEm: texto(g.recebidoEm), recibo: texto(g.recibo), evidencia: texto(g.evidencia), evidenciaSha256: texto(g.evidenciaSha256) };
+            }
+            else if (gates.length) {
+                estado = 'sem-prova';
+                lacuna(id, 'resposta.sem-prova');
+            }
+            else
+                lacuna(id, 'resposta.pendente');
+            // O prazo vai como está no pedido; vencido ou não é leitura de quem consulta, e o digest não depende do relógio.
+            decisoes.push({ ...comum, classe: tipo, contrato: p.contrato, autoria: estado === 'decidida' ? 'dono' : null, pergunta: String(p.pergunta),
+                sobre: (0, hitl_contract_1.alvoDoPedido)(p)?.tipo === 'gate' ? String((0, hitl_contract_1.alvoDoPedido)(p).sobre) : '', alternativas,
+                recomendacao: p.contrato === 'ork.hitl/v2' ? null : texto(p.recomendacao), prazo: texto(p.prazo),
+                estado, resposta });
+        }
+        else {
+            const rastro = (0, decisao_autonoma_1.rastroDaDecisao)(e);
+            decisoes.push({ ...comum, classe: tipo, contrato: 'legado', autoria: 'autonoma', decidido: texto(e.decisao) ?? '',
+                quemDecidiu: rastro.quemDecidiu ?? null, evidencia: rastro.evidencia ?? null, razao: rastro.razao ?? null, rastroCompleto: rastro.completa });
+            lacuna(id, 'decisao.fora-do-contrato');
+            lacuna(id, 'alternativas.nao-registradas');
+        }
+    }
+    const unicas = [...new Map(lacunas.map(x => [`${x.id} ${x.codigo}`, x])).values()]
+        .sort((a, b) => comparar(a.id, b.id) || comparar(a.codigo, b.codigo));
+    // D7: o digest cobre o digest do pacote de contexto, não o pacote inteiro; o horário fica fora.
+    const corpo = { ...base, state: (decisoes.length ? 'ok' : 'empty'), vinculo, contexto: contexto?.digest ?? null,
+        decisoes, lacunas: unicas };
+    return { ...corpo, contexto, digest: (0, company_brain_contract_1.digest)(corpo), consultadoEm: new Date().toISOString() };
+}

package/dist/company-brain-mcp.js

@@ -4,7 +4,8 @@ exports.BRAIN_WRITE_TOOLS = exports.BRAIN_READ_TOOLS = void 0;
 exports.registerBrainTools = registerBrainTools;
 const zod_1 = require("zod");
 const company_brain_cli_1 = require("./company-brain-cli");
-exports.BRAIN_READ_TOOLS = ['ork_brain_status', 'ork_brain_inventory', 'ork_brain_get', 'ork_brain_query', 'ork_brain_receipts'];
+const company_brain_dossie_1 = require("./company-brain-dossie");
+exports.BRAIN_READ_TOOLS = ['ork_brain_status', 'ork_brain_inventory', 'ork_brain_get', 'ork_brain_query', 'ork_brain_receipts', 'ork_brain_context', 'ork_brain_dossie'];
 exports.BRAIN_WRITE_TOOLS = ['ork_brain_sync', 'ork_brain_apply', 'ork_brain_rollback', 'ork_brain_bind'];
 /** Installation supplies exact grants; presence of a tool is never activation or human identity. */
 function registerBrainTools(register, load, checkThread, writeGrants = []) {
@@ -13,6 +14,8 @@ function registerBrainTools(register, load, checkThread, writeGrants = []) {
     const id = zod_1.z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/), base = zod_1.z.object({ threadId: id }).strict();
     const definitions = [['status', base], ['inventory', base], ['get', base.extend({ id })], ['receipts', base.extend({ id })],
         ['query', base.extend({ ids: zod_1.z.array(id).max(1000).optional(), kinds: zod_1.z.array(zod_1.z.enum(['prod', 'proj', 'init', 'assertion'])).optional(), limit: zod_1.z.number().int().min(1).max(1000).optional() })],
+        ['context', base.extend({ ids: zod_1.z.array(id).min(1).max(1000).optional() })],
+        ['dossie', base.extend({ decisao: zod_1.z.string().regex(company_brain_dossie_1.ID_DE_DECISAO).optional() })],
         ['sync', base], ['apply', base.extend({ plan: zod_1.z.string().min(1).max(512), expectedSha256: zod_1.z.string().regex(/^[a-f0-9]{64}$/) })],
         ['rollback', base.extend({ batch: id })], ['bind', base.extend({ project: id, initiatives: zod_1.z.array(id).min(1).max(1000) })]];
     for (const [operation, inputSchema] of definitions) {

package/dist/conducao.js

@@ -338,6 +338,18 @@ function vidaDoProcesso(raiz, threadId, lease) {
     fs.closeSync(fd);
     return 'morto';
 }
+/** Fecha a tomada uma vez so (RM-037, CHECK 4): liberar e devolver podem ser chamados mais de uma vez. */
+function encerrar(k, estado) {
+    if (estado.encerrada)
+        return;
+    estado.encerrada = true;
+    if (emCurso.get(k) === estado)
+        emCurso.delete(k);
+    try {
+        fs.closeSync(estado.fd);
+    }
+    catch { /* ja fechado */ }
+}
 /** Conducoes que ESTE processo segura, pela chave canonica: a reentrada no mesmo processo. */
 const emCurso = new Map();
 function chave(raiz, threadId) {
@@ -432,7 +444,7 @@ function liberarComProva(raiz, threadId, lease, tipo, dados) {
  * estava livre, entao ele morreu). Dono sessao vale ate a prova de fim. Reserva vale no prazo, e para
  * o mesmo canal vira a conducao dele.
  */
-function avaliarComTrava(raiz, threadId, pedido, opcoes = { usarReserva: true }) {
+function avaliarComTrava(raiz, threadId, pedido, opcoes = { usarReserva: true }, saida = {}) {
     const lease = (0, leases_1.lerLease)(raiz, nomeDaConducao(threadId));
     if (!lease)
         return null;
@@ -460,6 +472,7 @@ function avaliarComTrava(raiz, threadId, pedido, opcoes = { usarReserva: true })
             return null;
         }
         if (opcoes.usarReserva && atual.canal === pedido.canal) {
+            saida.substituido = lease;
             liberarComProva(raiz, threadId, lease, ledger_1.TIPOS_DE_EVENTO.conducaoLiberada, { motivo: 'reserva-usada', prova: `pedido do mesmo canal ${pedido.canal} de quem assumiu` });
             return null;
         }
@@ -477,6 +490,7 @@ function avaliarComTrava(raiz, threadId, pedido, opcoes = { usarReserva: true })
     // A sucessora (fluxo de superacao das sessoes HITL): a sessao `blocked` espera alguem e nao executa;
     // o despacho seguinte da MESMA fase a sucede, e a superacao a encerra pelo controle do runtime.
     if (despacho && mesmaFase && !mesmoPedido && estadoNoRuntime === 'blocked') {
+        saida.substituido = lease;
         liberarComProva(raiz, threadId, lease, ledger_1.TIPOS_DE_EVENTO.conducaoLiberada, {
             motivo: 'sessao-bloqueada-sucedida',
             prova: `runtime ${atual.dono.tipo === 'sessao' ? atual.dono.runtime : '?'}: estado blocked; o despacho seguinte da fase ${atual.fase} a sucede`,
@@ -497,7 +511,8 @@ function tomarConducao(raiz, threadId, pedido) {
     const propria = emCurso.get(k);
     if (propria && !propria.convertida) {
         propria.profundidade++;
-        return reentrada(propria.identidade, () => { propria.profundidade--; });
+        // R5-S2 do CHECK 5: a reentrada renova o lease de quem a segura (a baseline dentro da tomada retida).
+        return reentrada(propria.identidade, () => { propria.profundidade--; }, (prazo, agoraMs = Date.now()) => renovar(raiz, threadId, propria, prazo, agoraMs));
     }
     const existente = (0, leases_1.lerLease)(raiz, nomeDaConducao(threadId));
     if (pedido.identidade && existente?.conducao?.identidade === pedido.identidade) {
@@ -521,7 +536,8 @@ function tomarConducao(raiz, threadId, pedido) {
         return { ok: false, idempotente: false, atual };
     }
     try {
-        const ocupada = avaliarComTrava(raiz, threadId, pedido);
+        const saida = {};
+        const ocupada = avaliarComTrava(raiz, threadId, pedido, undefined, saida);
         if (ocupada) {
             fs.closeSync(fd);
             return ocupada;
@@ -537,7 +553,8 @@ function tomarConducao(raiz, threadId, pedido) {
             conducao: dadosDoPedido(pedido, identidade, donoProcesso()),
         };
         (0, leases_1.regravarLease)(raiz, lease);
-        const estado = { identidade, profundidade: 0, lease, fd, convertida: false };
+        const estado = { identidade, profundidade: 0, lease, fd, convertida: false, ...(saida.substituido ? { substituido: saida.substituido } : {}),
+            ...(pedido.consultarSessao ? { consultarSessao: pedido.consultarSessao } : {}) };
         emCurso.set(k, estado);
         return {
             ok: true,
@@ -546,6 +563,8 @@ function tomarConducao(raiz, threadId, pedido) {
             renovar: (prazoDoProximoMs, agoraMs = Date.now()) => renovar(raiz, threadId, estado, prazoDoProximoMs, agoraMs),
             converterEmSessao: (dados) => converter(raiz, k, estado, dados),
             liberar: () => liberarPropria(raiz, k, estado),
+            devolver: () => devolverPropria(raiz, threadId, k, estado),
+            sucessaoAindaVale: () => sucessaoAindaVale(raiz, threadId, estado),
         };
     }
     catch (e) {
@@ -556,20 +575,42 @@ function tomarConducao(raiz, threadId, pedido) {
         throw e;
     }
 }
-function reentrada(identidade, sair) {
+function reentrada(identidade, sair, renovarExterno = () => undefined) {
     let saiu = false;
     return {
         ok: true, reentrada: true, identidade,
-        renovar: () => undefined,
+        renovar: renovarExterno,
         converterEmSessao: () => undefined,
         liberar: () => { if (!saiu) {
             saiu = true;
             sair();
         } },
+        devolver: () => { if (!saiu) {
+            saiu = true;
+            sair();
+        } },
+        sucessaoAindaVale: () => true,
     };
 }
+/** Ver `ConducaoTomada.sucessaoAindaVale`. Sessao sucedida que voltou a trabalhar derruba a sucessao. */
+function sucessaoAindaVale(raiz, threadId, estado) {
+    // S2 do CHECK 6: tomada ja encerrada nao converte mais em sessao; despachar com ela deixaria a sessao sem lease.
+    if (estado.encerrada)
+        return false;
+    const dono = estado.substituido?.conducao?.dono;
+    if (!dono || dono.tipo !== 'sessao' || estado.convertida)
+        return true;
+    const r = (estado.consultarSessao ?? consultaNativa)(dono, raiz, threadId);
+    // Sem resposta do runtime nao ha prova de que ela segue parada: a sucessao nao vale.
+    if (!r.ok)
+        return false;
+    // S1 do CHECK 6: a sessao que sumiu do runtime, sem perfil, acabou; a mesma prova de `provaDeFimDaSessao`.
+    if (r.estado === null)
+        return !dono.perfil;
+    return r.estado === 'blocked' || TERMINAIS.includes(r.estado);
+}
 function renovar(raiz, threadId, estado, prazoDoProximoMs, agoraMs) {
-    if (estado.convertida)
+    if (estado.convertida || estado.encerrada)
         return;
     const falta = Date.parse(estado.lease.expiraEm) - agoraMs;
     if (falta >= prazoDoProximoMs + exports.MARGEM_DO_PRAZO_MS)
@@ -585,7 +626,7 @@ function renovar(raiz, threadId, estado, prazoDoProximoMs, agoraMs) {
     });
 }
 function converter(raiz, k, estado, dados) {
-    if (estado.convertida)
+    if (estado.convertida || estado.encerrada)
         return;
     const c = estado.lease.conducao;
     estado.lease = {
@@ -596,14 +637,30 @@ function converter(raiz, k, estado, dados) {
     };
     (0, leases_1.regravarLease)(raiz, estado.lease);
     estado.convertida = true;
-    emCurso.delete(k);
-    try {
-        fs.closeSync(estado.fd);
+    encerrar(k, estado);
+}
+function devolverPropria(raiz, threadId, k, estado) {
+    const anterior = estado.substituido;
+    if (estado.convertida || estado.encerrada || estado.profundidade > 0 || !anterior) {
+        liberarPropria(raiz, k, estado);
+        return;
     }
-    catch { /* ja fechado */ }
+    const atual = (0, leases_1.lerLease)(raiz, estado.lease.nome);
+    // So devolve por cima do proprio lease: outro dono que tenha chegado depois nunca e sobrescrito.
+    if (atual?.conducao?.identidade === estado.identidade && atual.conducao.dono.tipo === 'processo') {
+        (0, leases_1.regravarLease)(raiz, anterior);
+        const devolvida = (0, conducao_texto_1.conducaoDoLease)(anterior);
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.conducaoDevolvida, {
+            lease: anterior.nome,
+            devolvida: devolvida ? { canal: devolvida.canal, sessao: devolvida.sessao, fase: devolvida.fase, desde: devolvida.desde,
+                operacao: devolvida.operacao, dono: devolvida.dono } : null,
+            razao: 'o pedido foi recusado antes de virar sessao: o lease que a tomada consumiu volta a quem o tinha',
+        });
+    }
+    encerrar(k, estado);
 }
 function liberarPropria(raiz, k, estado) {
-    if (estado.convertida)
+    if (estado.convertida || estado.encerrada)
         return;
     if (estado.profundidade > 0) {
         estado.profundidade--;
@@ -616,11 +673,7 @@ function liberarPropria(raiz, k, estado) {
         }
         catch { /* ja saiu */ }
     }
-    emCurso.delete(k);
-    try {
-        fs.closeSync(estado.fd);
-    }
-    catch { /* ja fechado */ }
+    encerrar(k, estado);
 }
 /**
  * Registra a conducao da sessao de um despacho que nao tomou o lease antes (chamada direta de

package/dist/decisao-autonoma.js

@@ -39,7 +39,43 @@ const hitl_gates_1 = require("./hitl-gates");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
 const modos_1 = require("./modos");
+const conducao_1 = require("./conducao");
 exports.CONTRATO_DECISAO_AUTONOMA = 'ork.decisao-autonoma/v1';
+/**
+ * A sessao de OUTRA thread que registra aqui tambem deixa rastro (S-3 do CHECK 3). So o par que o ledger
+ * daquela thread confirma (S-b do CHECK 4): o par vazado do daemon do `claude --bg` nao vira rastro falso.
+ */
+function despachoDeOutraThread(raiz, threadId) {
+    const thread = (process.env[conducao_1.ENV_THREAD_DO_DESPACHO] ?? '').trim(), id = (process.env[conducao_1.ENV_IDENTIDADE_DE_DESPACHO] ?? '').trim();
+    if (!thread || thread === threadId || !/^[a-z0-9]{1,3}-[a-z0-9]{1,12}$/.test(thread) || !/^[a-f0-9-]{36}$/.test(id))
+        return {};
+    // R5-A2 do CHECK 5: a mesma conferencia D-4 da reentrada. O par que o daemon do `claude --bg` vazou e um
+    // despacho real, que o ledger confirma; so a sessao que o recebeu de fato o valida.
+    let confirmado = false;
+    try {
+        confirmado = (0, conducao_1.identidadeDoAmbiente)(thread, process.env, raiz) === id;
+    }
+    catch { /* thread de outro projeto ou ilegivel: sem prova, sem rastro */ }
+    if (confirmado) {
+        try {
+            confirmado = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread)).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada &&
+                e.identidade?.dispatchId === id);
+        }
+        catch {
+            confirmado = false;
+        }
+    }
+    return confirmado ? { despachoNoAmbiente: { thread, dispatchId: id } } : {};
+}
+/** O canal do processo; canal fora do registro nao impede a decisao, e fica dito como tal. */
+function canalSeguro() {
+    try {
+        return (0, conducao_1.canalDoProcesso)();
+    }
+    catch {
+        return 'desconhecido';
+    }
+}
 /** D3/M7: o p90 das 155 fases ja medidas. Acima disso a fase esta no decil mais alto do projeto. */
 exports.LIMIAR_DE_DECISOES_POR_FASE = 13;
 /** Os nomes que o rastro teve antes de ser tipado (M6), na ordem em que valem na leitura. */
@@ -110,6 +146,12 @@ function registrarDecisao(raiz, threadId, entrada) {
         const evento = (0, ledger_1.registrar)(dir, t.id, ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma, {
             contratoDecisao: exports.CONTRATO_DECISAO_AUTONOMA, fase: pedido.fase, decisao: pedido.decidido, ...rastro,
             pedido, ...(entrada.reverte ? { reverte: entrada.reverte } : {}),
+            origem: entrada.origem ?? 'cli', ...(entrada.host ? { host: entrada.host } : {}),
+            // RM-037 (S5 do CHECK): a porta e quem chamou, pelo processo e nao pelo texto de `quemDecidiu`. A sessao
+            // despachada carrega a identidade do despacho no ambiente; o dono no terminal, nao.
+            canal: entrada.origem === 'mcp' && entrada.host ? entrada.host : canalSeguro(),
+            despacho: entrada.despacho !== undefined ? entrada.despacho : (0, conducao_1.identidadeDoAmbiente)(t.id, process.env, raiz),
+            ...despachoDeOutraThread(raiz, t.id),
         });
         return { pedido, evento };
     });