@orkastery/cli 0.2.0 → 0.4.1

package/dist/roadmap-reservas.js

@@ -0,0 +1,243 @@
+"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.REMOTO_PADRAO = exports.BRANCH_DE_RESERVAS = exports.CONTRATO_RESERVA = void 0;
+exports.exigirItem = exigirItem;
+exports.quemSouEu = quemSouEu;
+exports.reservasLocais = reservasLocais;
+exports.listarReservas = listarReservas;
+exports.painelEmMarkdown = painelEmMarkdown;
+exports.pegarItem = pegarItem;
+exports.soltarItem = soltarItem;
+exports.textoDasReservas = textoDasReservas;
+/**
+ * I-47: reservas de item do roadmap entre maquinas, como documentacao em codigo.
+ *
+ * Mais de um computador (ou builder) trabalha no mesmo repositorio. Sem reserva, dois pegam o
+ * mesmo item e so descobrem no PR. A reserva e um arquivo por item (`reservas/RM-042.json`,
+ * contrato `ork.roadmap-reserva/v1`) numa branch propria, `ork/roadmap-reservas`, ao lado de um
+ * `RESERVAS.md` legivel no GitHub. Ela nao passa por PR nem por CI e nao mexe na `main`.
+ *
+ * A atomicidade vem do proprio git: a nova versao da branch e um commit em cima da ponta lida, e
+ * o push nunca e forcado. Se outra maquina gravou antes, o push e recusado, a leitura e refeita e
+ * a regra roda de novo sobre o estado novo. O primeiro push vence; o segundo ve a reserva do
+ * primeiro e recusa com `roadmap.reservado`, dizendo com quem esta o item.
+ *
+ * Nada aqui toca a arvore de trabalho nem o indice do repositorio: blobs, arvore e commit sao
+ * montados com um indice temporario, e a branch local de reservas nunca e criada. A mecanica e a
+ * de `branch-de-estado.ts`, a mesma do estado compartilhado da fabrica (I-51).
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const branch_de_estado_1 = require("./branch-de-estado");
+const horario_1 = require("./horario");
+const maquina_1 = require("./maquina");
+const util_1 = require("./util");
+exports.CONTRATO_RESERVA = 'ork.roadmap-reserva/v1';
+exports.BRANCH_DE_RESERVAS = 'ork/roadmap-reservas';
+exports.REMOTO_PADRAO = 'origin';
+const DIR = 'reservas';
+const PAINEL = 'RESERVAS.md';
+const TENTATIVAS = 5;
+const ITEM = /^RM-\d{3}$/;
+const PREFIXO = 'roadmap';
+/** O item precisa existir no roadmap do projeto (`docs/roadmap/RM-NNN-*.md`). */
+function exigirItem(raiz, item) {
+    const id = item.trim().toUpperCase();
+    if (!ITEM.test(id))
+        throw new Error(`roadmap.item: "${item}" nao e um item do roadmap (esperado RM-NNN)`);
+    const dir = path.join(raiz, 'docs', 'roadmap');
+    const doItem = (f) => path.basename(f).startsWith(`${id}-`) && f.endsWith('.md');
+    const naArvore = fs.existsSync(dir) && fs.readdirSync(dir).some(doItem);
+    // O checkout pode estar numa branch antiga, sem o item: vale tambem o que a main ja tem.
+    const naBase = !naArvore && ['main', 'origin/main'].some((ref) => (0, branch_de_estado_1.git)(raiz, ['ls-tree', '--name-only', ref, '--', 'docs/roadmap/']).stdout.split('\n').some(doItem));
+    if (!naArvore && !naBase)
+        throw new Error(`roadmap.item: ${id} nao existe em docs/roadmap`);
+    return id;
+}
+/** Quem esta pegando: `--por`, senao o `user.name` do git, senao o usuario do sistema. */
+function quemSouEu(raiz, opcoes = {}) {
+    const doGit = (0, branch_de_estado_1.git)(raiz, ['config', 'user.name']).stdout.trim();
+    const por = (opcoes.por ?? '').trim() || doGit || os.userInfo().username;
+    return { por, maquina: (0, maquina_1.nomeDaMaquina)(opcoes.maquina) };
+}
+/** Traz a ponta da branch de reservas. `null` quando ela ainda nao existe no remoto. */
+function buscar(raiz, remoto) {
+    return (0, branch_de_estado_1.buscarBranch)(raiz, remoto, exports.BRANCH_DE_RESERVAS, PREFIXO);
+}
+function lerDaPonta(raiz, ponta) {
+    return (0, branch_de_estado_1.jsonsDaPonta)(raiz, ponta, DIR, PREFIXO)
+        .filter((r) => r.contrato === exports.CONTRATO_RESERVA)
+        .sort((a, b) => a.item.localeCompare(b.item));
+}
+/** As reservas da ultima copia lida nesta maquina, sem rede (I-51: o retrato da fabrica usa). */
+function reservasLocais(raiz, remoto = exports.REMOTO_PADRAO) {
+    try {
+        return lerDaPonta(raiz, (0, branch_de_estado_1.pontaLocal)(raiz, remoto, exports.BRANCH_DE_RESERVAS));
+    }
+    catch {
+        return [];
+    }
+}
+/** `ork roadmap reservas`: quem esta com cada item, lido do remoto (ou da ultima copia, sem rede). */
+function listarReservas(raiz, opcoes = {}) {
+    const { ponta, atualizado } = buscar(raiz, opcoes.remoto ?? exports.REMOTO_PADRAO);
+    return { reservas: lerDaPonta(raiz, ponta), atualizado, ponta };
+}
+/** O `RESERVAS.md` da branch: a mesma lista, para quem abre o GitHub. */
+function painelEmMarkdown(reservas) {
+    const linhas = [
+        '# Reservas do roadmap',
+        '',
+        'Quem está com cada item agora. Gerado pelo `ork roadmap pegar` e pelo `ork roadmap soltar`;',
+        'não edite à mão. Antes de começar um item: `ork roadmap reservas`.',
+        '',
+    ];
+    if (reservas.length === 0)
+        return [...linhas, 'Nenhum item reservado.', ''].join('\n');
+    linhas.push('| Item | Com quem | Máquina | Thread | Desde | Nota |', '| --- | --- | --- | --- | --- | --- |');
+    for (const r of reservas) {
+        linhas.push(`| ${r.item} | ${r.por} | ${r.maquina} | ${r.thread ?? '—'} | ${(0, horario_1.formatarDataHora)(r.desdeEm)} | ${r.nota ?? '—'} |`);
+    }
+    return [...linhas, '', (0, horario_1.legendaDoFuso)(), ''].join('\n');
+}
+/** Grava a reserva (ou a remocao dela) e o painel numa versao nova da branch. Recusa volta `false`. */
+function gravar(raiz, remoto, ponta, mudanca, todas, mensagem) {
+    return (0, branch_de_estado_1.gravarNaBranch)(raiz, remoto, exports.BRANCH_DE_RESERVAS, ponta, [
+        { caminho: `${DIR}/${mudanca.item}.json`, conteudo: mudanca.reserva ? JSON.stringify(mudanca.reserva, null, 2) + '\n' : null },
+        { caminho: PAINEL, conteudo: painelEmMarkdown(todas) },
+    ], mensagem, PREFIXO);
+}
+function ehMinha(r, eu) {
+    return r.por === eu.por && r.maquina === eu.maquina;
+}
+function descrever(r) {
+    return `${r.item} esta com ${r.por} em ${r.maquina} desde ${(0, horario_1.formatarDataHora)(r.desdeEm)}` +
+        (r.thread ? ` (thread ${r.thread})` : '');
+}
+function exigirMotivo(opcoes) {
+    const motivo = (opcoes.motivo ?? '').trim();
+    if (!motivo)
+        throw new Error('roadmap.forcar: --forcar exige --motivo (tomar a reserva de outra maquina e decisao registrada)');
+    return motivo;
+}
+/**
+ * `ork roadmap pegar`: reserva o item para esta maquina. Renovar a propria reserva e idempotente
+ * (atualiza thread, nota e carimbo); a de outra maquina so sai com `--forcar --motivo`.
+ */
+function pegarItem(raiz, item, opcoes = {}) {
+    const id = exigirItem(raiz, item);
+    const remoto = opcoes.remoto ?? exports.REMOTO_PADRAO;
+    const eu = quemSouEu(raiz, opcoes);
+    for (let tentativa = 1; tentativa <= TENTATIVAS; tentativa++) {
+        const { ponta, atualizado } = buscar(raiz, remoto);
+        if (!atualizado)
+            throw new Error(`roadmap.sem-remoto: nao consegui ler ${exports.BRANCH_DE_RESERVAS} em ${remoto}; reservar exige rede`);
+        const todas = lerDaPonta(raiz, ponta);
+        const atual = todas.find((r) => r.item === id) ?? null;
+        const quando = opcoes.agora ?? (0, util_1.agora)();
+        let acao = 'pegou';
+        let tomadaDe;
+        if (atual && ehMinha(atual, eu))
+            acao = 'renovou';
+        else if (atual) {
+            if (!opcoes.forcar)
+                throw new Error(`roadmap.reservado: ${descrever(atual)}. Escolha outro item ou combine com quem esta nele`);
+            tomadaDe = { por: atual.por, maquina: atual.maquina, motivo: exigirMotivo(opcoes) };
+            acao = 'tomou';
+        }
+        const reserva = {
+            contrato: exports.CONTRATO_RESERVA, item: id, por: eu.por, maquina: eu.maquina,
+            thread: opcoes.thread !== undefined ? opcoes.thread : (acao === 'renovou' ? atual.thread : null),
+            nota: opcoes.nota !== undefined ? opcoes.nota : (acao === 'renovou' ? atual.nota : null),
+            desdeEm: acao === 'renovou' ? atual.desdeEm : quando,
+            atualizadaEm: quando,
+            ...(tomadaDe ? { tomadaDe } : {}),
+        };
+        const novas = [...todas.filter((r) => r.item !== id), reserva].sort((a, b) => a.item.localeCompare(b.item));
+        const mensagem = acao === 'tomou'
+            ? `reserva: ${id} tomada por ${eu.por} em ${eu.maquina} (de ${tomadaDe.por} em ${tomadaDe.maquina}): ${tomadaDe.motivo}`
+            : `reserva: ${id} ${acao === 'renovou' ? 'renovada' : 'pega'} por ${eu.por} em ${eu.maquina}`;
+        const commit = gravar(raiz, remoto, ponta, { item: id, reserva }, novas, mensagem);
+        if (commit)
+            return { acao, item: id, reserva, commit, tentativas: tentativa };
+    }
+    throw new Error(`roadmap.concorrencia: ${TENTATIVAS} pushes recusados seguidos; tente de novo em instantes`);
+}
+/** `ork roadmap soltar`: devolve o item. Soltar a reserva de outra maquina exige `--forcar --motivo`. */
+function soltarItem(raiz, item, opcoes = {}) {
+    const id = exigirItem(raiz, item);
+    const remoto = opcoes.remoto ?? exports.REMOTO_PADRAO;
+    const eu = quemSouEu(raiz, opcoes);
+    for (let tentativa = 1; tentativa <= TENTATIVAS; tentativa++) {
+        const { ponta, atualizado } = buscar(raiz, remoto);
+        if (!atualizado)
+            throw new Error(`roadmap.sem-remoto: nao consegui ler ${exports.BRANCH_DE_RESERVAS} em ${remoto}; soltar exige rede`);
+        const todas = lerDaPonta(raiz, ponta);
+        const atual = todas.find((r) => r.item === id);
+        if (!atual)
+            return { acao: 'nada', item: id, reserva: null, commit: null, tentativas: tentativa };
+        let motivo = '';
+        if (!ehMinha(atual, eu)) {
+            if (!opcoes.forcar)
+                throw new Error(`roadmap.reservado: ${descrever(atual)}; so quem pegou solta, ou --forcar --motivo`);
+            motivo = `: ${exigirMotivo(opcoes)}`;
+        }
+        const restantes = todas.filter((r) => r.item !== id);
+        const mensagem = `reserva: ${id} solta por ${eu.por} em ${eu.maquina}${motivo}`;
+        const commit = gravar(raiz, remoto, ponta, { item: id, reserva: null }, restantes, mensagem);
+        if (commit)
+            return { acao: 'soltou', item: id, reserva: atual, commit, tentativas: tentativa };
+    }
+    throw new Error(`roadmap.concorrencia: ${TENTATIVAS} pushes recusados seguidos; tente de novo em instantes`);
+}
+/** O texto de `ork roadmap reservas` para o terminal, no fuso do dono. */
+function textoDasReservas(p) {
+    const linhas = [];
+    if (!p.atualizado)
+        linhas.push('AVISO: sem acesso ao remoto; esta e a ultima copia lida nesta maquina.', '');
+    if (p.reservas.length === 0) {
+        linhas.push('Nenhum item do roadmap reservado.');
+        return linhas.join('\n');
+    }
+    linhas.push('ITEM     COM QUEM            MAQUINA         THREAD             DESDE');
+    for (const r of p.reservas) {
+        linhas.push(`${r.item.padEnd(8)} ${r.por.slice(0, 19).padEnd(19)} ${r.maquina.slice(0, 15).padEnd(15)} ` +
+            `${(r.thread ?? '-').slice(0, 18).padEnd(18)} ${(0, horario_1.formatarDataHora)(r.desdeEm)}` + (r.nota ? `  ${r.nota}` : ''));
+    }
+    linhas.push('', (0, horario_1.legendaDoFuso)());
+    return linhas.join('\n');
+}

package/dist/runtime-ambiente.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENVS_DE_PROVIDER_PAGO = void 0;
+exports.nomesDeProviderAtivos = nomesDeProviderAtivos;
+exports.ambienteDeAssinatura = ambienteDeAssinatura;
+const hitl_public_receipt_1 = require("./hitl-public-receipt");
+/**
+ * Lista explícita removida dos runtimes homologados. Nunca registra valores.
+ * Não é uma lista de todas as formas de redirecionamento: proxies genéricos,
+ * cabeçalhos personalizados e credenciais de outros serviços ficam fora do contrato.
+ */
+exports.ENVS_DE_PROVIDER_PAGO = [
+    'ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL',
+    'CLAUDE_CODE_USE_BEDROCK', 'CLAUDE_CODE_USE_VERTEX',
+    'OPENAI_API_KEY', 'OPENAI_BASE_URL', 'OPENROUTER_API_KEY', 'OPENROUTER_BASE_URL',
+    'GEMINI_API_KEY', 'GOOGLE_API_KEY', 'AZURE_OPENAI_API_KEY', 'AZURE_OPENAI_ENDPOINT',
+    'MISTRAL_API_KEY', 'GROQ_API_KEY', 'DEEPSEEK_API_KEY', 'TOGETHER_API_KEY',
+];
+/** Retrato de presença, sem guardar valores ou credenciais. */
+function nomesDeProviderAtivos(base = process.env) {
+    return exports.ENVS_DE_PROVIDER_PAGO.filter(nome => (base[nome] ?? '').trim() !== '');
+}
+/** Copia, sem alterar o ambiente em que as policies ainda precisam ser avaliadas. */
+function ambienteDeAssinatura(base = process.env) {
+    const env = { ...base };
+    const publicVerifiers = (0, hitl_public_receipt_1.publicHitlVerifiers)(base);
+    for (const nome of exports.ENVS_DE_PROVIDER_PAGO)
+        delete env[nome];
+    // A autoridade de ingresso pertence ao processo do host/núcleo. Um executor
+    // de código não recebe chaves, bindings ou allowlists de respostas humanas.
+    for (const nome of Object.keys(env))
+        if (nome.startsWith('ORK_HITL_'))
+            delete env[nome];
+    delete env[hitl_public_receipt_1.ENV_HITL_VERIFIERS];
+    if (publicVerifiers)
+        env[hitl_public_receipt_1.ENV_HITL_VERIFIERS] = publicVerifiers;
+    return env;
+}

package/dist/runtime-context.js

@@ -0,0 +1,215 @@
+"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.novaIdentidadeDeDespacho = novaIdentidadeDeDespacho;
+exports.contextoDoProjeto = contextoDoProjeto;
+exports.validarContextoRuntime = validarContextoRuntime;
+/** Contexto interno opt-in: configuracao M4 existente + catalogo instalado, nunca args do modelo. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const smol_toml_1 = require("smol-toml");
+const manifest_1 = require("./manifest");
+const thread_1 = require("./thread");
+const hosts_1 = require("./hosts");
+const worktree_1 = require("./worktree");
+const mcp_install_1 = require("./mcp-install");
+const hitl_public_receipt_1 = require("./hitl-public-receipt");
+/** Correlação interna; nenhuma identidade de despacho concede poder de gate. */
+function novaIdentidadeDeDespacho(threadId, fase) {
+    return { schema: 'ork.dispatch-identity/v1', dispatchId: (0, node_crypto_1.randomUUID)(), threadId, role: fase === 'CHECK' ? 'reviewer' : 'executor' };
+}
+function objeto(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        throw Error('runtime.context.invalid: objeto esperado');
+    return v;
+}
+function dentro(raiz, file) {
+    const real = fs.realpathSync(file);
+    if (real !== raiz && !real.startsWith(raiz + path.sep))
+        throw Error('runtime.context.scope: caminho fora do projeto');
+    return real;
+}
+function ler(raiz, file, limite) {
+    dentro(raiz, file);
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.size > limite)
+            throw Error('runtime.context.invalid: arquivo invalido');
+        const bytes = fs.readFileSync(fd);
+        if (bytes.length > limite)
+            throw Error('runtime.context.invalid: arquivo excedeu limite');
+        return bytes;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function preparado(raiz) {
+    let encontrado;
+    for (const host of ['claude-code', 'codex']) {
+        const file = path.join(raiz, host === 'codex' ? '.codex/config.toml' : '.mcp.json');
+        if (!fs.existsSync(file))
+            continue;
+        const text = ler(raiz, file, 262144).toString('utf8');
+        const config = objeto(host === 'codex' ? (0, smol_toml_1.parse)(text) : JSON.parse(text));
+        const chave = host === 'codex' ? 'mcp_servers' : 'mcpServers';
+        if (config[chave] === undefined)
+            continue;
+        const servidores = objeto(config[chave]);
+        if (!Object.hasOwn(servidores, 'orkastery'))
+            continue;
+        const entrada = objeto(servidores.orkastery), padrao = (0, mcp_install_1.configuracaoServidorMcp)(raiz, host);
+        const legado = padrao.args.slice(0, -2);
+        let transporte = 'github-ssh';
+        let argv = entrada.args;
+        let permissoesFilho = 'interactive';
+        if (Array.isArray(argv) && argv[argv.length - 2] === '--child-permissions') {
+            if (!['interactive', 'worktree'].includes(argv[argv.length - 1]))
+                throw Error('runtime.context.conflict: perfil de filho invalido');
+            permissoesFilho = argv[argv.length - 1];
+            argv = argv.slice(0, -2);
+        }
+        if (JSON.stringify(argv) !== JSON.stringify(legado)) {
+            if (!Array.isArray(argv) || argv.length !== padrao.args.length ||
+                argv[argv.length - 2] !== '--ship-transport' || !['github-ssh', 'bare-local'].includes(argv[argv.length - 1]))
+                throw Error('runtime.context.conflict: MCP Orkastery divergente; transporte invalido ou argumentos extras');
+            transporte = argv[argv.length - 1];
+        }
+        const esperado = (0, mcp_install_1.configuracaoServidorMcp)(raiz, host, undefined, transporte);
+        if (entrada.command !== esperado.command || (JSON.stringify(argv) !== JSON.stringify(esperado.args) && JSON.stringify(argv) !== JSON.stringify(legado)))
+            throw Error('runtime.context.conflict: MCP Orkastery divergente; repare a instalacao do projeto');
+        if (encontrado !== undefined && encontrado.transporteShip !== transporte)
+            throw Error('runtime.context.conflict: transportes SHIP divergentes entre hosts');
+        if (encontrado !== undefined && encontrado.permissoesFilho !== permissoesFilho)
+            throw Error('runtime.context.conflict: perfis de filho divergentes entre hosts');
+        encontrado = { ...encontrado, transporteShip: transporte, permissoesFilho, ...(host === 'codex' ? { politicasCodex: entrada } : {}) };
+    }
+    return encontrado;
+}
+function raizCanonica(projeto) {
+    if (!path.isAbsolute(projeto))
+        throw Error('runtime.context.invalid: projeto absoluto obrigatorio');
+    const raiz = fs.realpathSync(projeto);
+    if (raiz !== projeto || fs.realpathSync((0, manifest_1.exigirManifesto)(raiz).raiz) !== raiz)
+        throw Error('runtime.context.invalid: raiz canonica do manifesto obrigatoria');
+    if (fs.existsSync(path.join(raiz, '.orkastery')))
+        dentro(raiz, path.join(raiz, '.orkastery'));
+    return raiz;
+}
+/** Projeto sem entrada MCP Orkastery continua com o contrato legado. Nao instala nem altera arquivos. */
+function contextoDoProjeto(projeto, runtime, cwd, threadId) {
+    const raiz = raizCanonica(projeto);
+    const perfil = preparado(raiz);
+    if (!perfil)
+        return undefined;
+    if (!['claude-bg', 'codex'].includes(runtime))
+        throw Error('runtime.context.invalid: runtime desconhecido');
+    if (!threadId)
+        throw Error('runtime.context.invalid: thread obrigatoria para sessao filha');
+    const contexto = { projeto: raiz, host: runtime === 'codex' ? 'codex' : 'claude-code', threadId, transporteShip: perfil.transporteShip, permissoesFilho: perfil.permissoesFilho };
+    validarContextoRuntime(contexto, cwd);
+    return contexto;
+}
+/** Revalida no receptor do despacho, incluindo bytes instalados e escopo real do cwd. */
+function validarContextoRuntime(contexto, cwd) {
+    if (!contexto || !['claude-code', 'codex'].includes(contexto.host))
+        throw Error('runtime.context.invalid: host desconhecido');
+    if (contexto.transporteShip !== undefined && !['github-ssh', 'bare-local'].includes(contexto.transporteShip))
+        throw Error('runtime.context.invalid: transporte desconhecido');
+    const raiz = raizCanonica(contexto.projeto);
+    if (contexto.permissoesFilho !== undefined && !['interactive', 'worktree'].includes(contexto.permissoesFilho))
+        throw Error('runtime.context.invalid: perfil de filho desconhecido');
+    const perfil = preparado(raiz);
+    if (!perfil)
+        throw Error('runtime.context.missing: projeto nao preparado pelo instalador MCP');
+    const { transporteShip, permissoesFilho } = perfil;
+    if ((contexto.permissoesFilho ?? 'interactive') !== permissoesFilho)
+        throw Error('runtime.context.conflict: perfil de filho difere da instalacao');
+    if ((contexto.transporteShip ?? 'github-ssh') !== transporteShip)
+        throw Error('runtime.context.conflict: transporte SHIP difere da instalacao');
+    if (!path.isAbsolute(cwd) || dentro(raiz, cwd) !== cwd)
+        throw Error('runtime.context.scope: cwd divergente');
+    if (typeof contexto.threadId !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(contexto.threadId))
+        throw Error('runtime.context.invalid: identidade da thread invalida');
+    if (contexto.identidade && (contexto.identidade.schema !== 'ork.dispatch-identity/v1' ||
+        contexto.identidade.threadId !== contexto.threadId || !['executor', 'reviewer'].includes(contexto.identidade.role) ||
+        !/^[a-f0-9-]{36}$/.test(contexto.identidade.dispatchId)))
+        throw Error('runtime.context.identity');
+    dentro(raiz, (0, thread_1.dirThread)(raiz, contexto.threadId));
+    const thread = (0, thread_1.lerThread)(raiz, contexto.threadId);
+    if (thread.id !== contexto.threadId || fs.realpathSync(thread.worktree ?? raiz) !== cwd)
+        throw Error('runtime.context.scope: cwd nao corresponde a thread vinculada');
+    if (permissoesFilho === 'worktree') {
+        if (thread.status === 'fechada' || !thread.worktree || thread.worktree === raiz || thread.worktree !== cwd ||
+            !fs.lstatSync(thread.worktree).isDirectory() || fs.realpathSync(thread.worktree) !== thread.worktree)
+            throw Error('runtime.context.worktree: perfil exige thread aberta e worktree fisica propria');
+        if (!(0, worktree_1.worktreesDoGit)(raiz).some(w => w.dir === cwd && w.branch === (0, worktree_1.branchDaWorktree)(thread)))
+            throw Error('runtime.context.worktree: worktree nao registrada na branch da thread');
+    }
+    const def = hosts_1.HOSTS[contexto.host];
+    const instalacao = path.join(raiz, def.destinoPadrao, def.subdir ?? '');
+    let recibo;
+    try {
+        recibo = objeto(JSON.parse(ler(raiz, path.join(instalacao, 'INSTALADO.json'), 1048576).toString('utf8')));
+    }
+    catch {
+        throw Error('runtime.context.installation: instale/verifique o adaptador do runtime neste projeto');
+    }
+    if (recibo.contrato !== 'ork.adapter-install/v1' || recibo.host !== contexto.host || !Array.isArray(recibo.arquivos) || recibo.arquivos.length > 512)
+        throw Error('runtime.context.installation: recibo instalado invalido');
+    const arquivos = new Map();
+    for (const item of recibo.arquivos) {
+        const a = objeto(item);
+        if (typeof a.arquivo !== 'string' || path.isAbsolute(a.arquivo) || a.arquivo.split(/[\\/]/).includes('..') ||
+            typeof a.sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(a.sha256) || arquivos.has(a.arquivo))
+            throw Error('runtime.context.installation: arquivo do recibo invalido');
+        const file = path.join(instalacao, a.arquivo);
+        if (!dentro(raiz, file).startsWith(instalacao + path.sep) || (0, node_crypto_1.createHash)('sha256').update(ler(raiz, file, 1048576)).digest('hex') !== a.sha256)
+            throw Error('runtime.context.installation: bytes instalados divergentes');
+        arquivos.set(a.arquivo, file);
+    }
+    const bootstrap = arquivos.get('skills/core/orkastery-bootstrap/SKILL.md');
+    if (!bootstrap || (contexto.host === 'claude-code' && !arquivos.has('.claude-plugin/plugin.json')))
+        throw Error('runtime.context.installation: catalogo ou plugin incompleto');
+    // Capacidade derivada do bloco atual, nunca aceita como entrada do modelo.
+    const permiteEditarProduto = permissoesFilho === 'worktree' && (0, thread_1.blocoDaThread)(thread, thread.faseAtual).fases.includes('GO');
+    const publicVerifiers = (0, hitl_public_receipt_1.publicHitlVerifiers)();
+    const servidor = { ...(0, mcp_install_1.configuracaoServidorMcp)(raiz, contexto.host, contexto.threadId, transporteShip, permissoesFilho, contexto.identidade?.dispatchId),
+        ...(publicVerifiers ? { env: { [hitl_public_receipt_1.ENV_HITL_VERIFIERS]: publicVerifiers } } : {}),
+        ...(contexto.host === 'codex' && permissoesFilho === 'worktree' ? (0, mcp_install_1.politicasFilhoCodex)(perfil.politicasCodex ?? {}) : {}) };
+    return { projeto: raiz, instalacao, bootstrap, permissoesFilho, permiteEditarProduto, servidor };
+}