@orkastery/cli 0.2.0 → 0.3.0

package/dist/adapters/codex-controller-worker.js

@@ -0,0 +1,361 @@
+"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 });
+/** Dono exclusivo do stdin app-server. IPC local autenticado pelo uid/diretório 0700. */
+const fs = __importStar(require("node:fs"));
+const net = __importStar(require("node:net"));
+const readline = __importStar(require("node:readline"));
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const codex_question_1 = require("./codex-question");
+const runtime_context_1 = require("../runtime-context");
+const codex_controller_1 = require("./codex-controller");
+function gravar(nome, valor) {
+    const tmp = `${nome}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(valor), { flag: 'wx', mode: 0o600 });
+    fs.renameSync(tmp, nome);
+}
+async function cliente() {
+    (0, codex_controller_1.conferirDiretorio)(process.cwd());
+    const entrada = fs.readFileSync(0, 'utf8');
+    const socket = net.createConnection('control.sock');
+    socket.setTimeout(11000, () => socket.destroy(new Error('timeout')));
+    socket.once('connect', () => socket.end(entrada + '\n'));
+    socket.on('data', b => process.stdout.write(b));
+    socket.on('error', () => { process.exitCode = 1; });
+}
+async function servidor() {
+    (0, codex_controller_1.conferirDiretorio)(process.cwd());
+    const bootstrap = JSON.parse(fs.readFileSync(0, 'utf8'));
+    const pedido = bootstrap.pedido;
+    const state = { instancia: bootstrap.instancia, processoController: (0, codex_controller_1.identidadeDoProcesso)(process.pid), vinculo: pedido.vinculo, cwd: pedido.cwd,
+        sessionId: '', pid: process.pid, estado: 'starting' };
+    const salvar = () => gravar('state.json', state);
+    salvar();
+    const child = (0, node_child_process_1.spawn)('codex', ['app-server', '--listen', 'stdio://', '-c', 'model_provider="openai"'], { cwd: pedido.cwd, env: process.env, stdio: ['pipe', 'pipe', 'pipe'] });
+    state.runtimePid = child.pid;
+    // PID vem do ChildProcess criado aqui; starttime evita confundir reutilização de PID.
+    if (child.pid && process.platform === 'linux') {
+        try {
+            state.processoRuntime = (0, codex_controller_1.identidadeDoProcesso)(child.pid);
+            state.runtimeInicio = state.processoRuntime.inicio;
+        }
+        catch { /* falha de spawn será registrada pelo evento close */ }
+    }
+    salvar();
+    child.stdin.on('error', () => { });
+    child.stderr.resume(); // nunca persistir stderr potencialmente sensível
+    let seq = 0, vivo = true, pergunta = null, intencao = null;
+    const chamadas = new Map();
+    const send = (v) => { if (!vivo)
+        throw new Error('runtime encerrado'); child.stdin.write(JSON.stringify(v) + '\n'); };
+    const rpc = (method, params) => new Promise((resolve, reject) => {
+        const id = ++seq, timeout = setTimeout(() => { chamadas.delete(id); reject(new Error('runtime.unavailable: timeout nativo')); }, 8000);
+        chamadas.set(id, { resolve: v => { clearTimeout(timeout); resolve(v); }, reject: e => { clearTimeout(timeout); reject(e); } });
+        send({ id, method, params });
+    });
+    const aguardar = async (condicao) => {
+        const fim = Date.now() + 8000;
+        while (!condicao() && vivo && Date.now() < fim)
+            await new Promise(r => setTimeout(r, 20));
+        if (!condicao())
+            throw new Error('runtime.unavailable: confirmação nativa ausente');
+    };
+    let encerrando = false;
+    const encerrar = async (motivo) => {
+        if (encerrando || !vivo)
+            return;
+        encerrando = true;
+        state.encerramentoSolicitado = motivo;
+        state.estado = 'unavailable';
+        salvar();
+        try {
+            if (state.sessionId && state.turno && !state.terminal)
+                await rpc('turn/interrupt', { threadId: state.sessionId, turnId: state.turno });
+        }
+        catch { /* EOF próprio abaixo; sem confirmação nativa não inventar terminal */ }
+        finally {
+            child.stdin.end();
+        }
+    };
+    const inicio = performance.now();
+    const vigia = setInterval(() => {
+        let stop;
+        try {
+            stop = JSON.parse(fs.readFileSync('stop-request.json', 'utf8'));
+        }
+        catch { /* não solicitado */ }
+        if (stop?.instancia === state.instancia)
+            void encerrar('dispatch.cancelled');
+        else if (!state.pronto && Date.now() >= Date.parse(bootstrap.prazoInicial))
+            void encerrar('dispatch.timeout');
+        else if (performance.now() - inicio >= bootstrap.duracaoMaximaMs)
+            void encerrar('turn.timeout');
+    }, 50);
+    const recusarPedido = (codigo, method) => {
+        state.estado = 'unavailable';
+        state.limitacao = { motivo: 'runtime.unavailable', codigo, metodo: method };
+        delete state.perguntaNativa;
+        delete state.bloqueio;
+        pergunta = null;
+        salvar();
+        // Interrupção da MESMA thread/turno, sem responder/aprovar a ferramenta nativa.
+        void rpc('turn/interrupt', { threadId: state.sessionId, turnId: state.turno }).catch(() => {
+            state.erro = 'runtime.unavailable: interrupção de capacidade não suportada não confirmada';
+            salvar();
+            child.stdin.end();
+        });
+    };
+    readline.createInterface({ input: child.stdout }).on('line', line => {
+        let v;
+        try {
+            v = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!v.method && chamadas.has(v.id)) {
+            const p = chamadas.get(v.id);
+            chamadas.delete(v.id);
+            v.error ? p.reject(new Error('runtime.unavailable: RPC nativo recusado')) : p.resolve(v.result);
+            return;
+        }
+        const p = v.params;
+        if (p?.threadId !== state.sessionId || v.method === 'item/tool/requestUserInput' && p.turnId !== state.turno) {
+            if (v.id !== undefined && v.method)
+                recusarPedido('request.uncorrelated', 'request/unsupported');
+            return;
+        }
+        if (v.method === 'turn/started') {
+            state.turno = p.turn.id;
+            state.estado = 'working';
+        }
+        if (v.method === 'item/tool/requestUserInput' && p.turnId === state.turno) {
+            try {
+                state.perguntaNativa = (0, codex_question_1.projetarPergunta)(p);
+                pergunta = v;
+                state.estado = 'blocked';
+                state.bloqueio = JSON.stringify([p.turnId, v.id, p.itemId, state.perguntaNativa.sha256]);
+            }
+            catch (e) {
+                recusarPedido(e.message.replace('runtime.unavailable: ', ''), v.method);
+            }
+        }
+        if (v.id !== undefined && v.method !== 'item/tool/requestUserInput')
+            recusarPedido('request.unsupported', v.method);
+        if (v.method === 'serverRequest/resolved' && pergunta && p.requestId === pergunta.id) {
+            if (intencao) {
+                const ack = { ...intencao, estado: 'recebida' };
+                gravar(`receipt-${intencao.envioId}.json`, ack);
+                gravar(`native-${intencao.envioId}.json`, { metodo: v.method, requestId: p.requestId, threadId: p.threadId, turnId: state.turno, itemId: pergunta.params.itemId });
+            }
+            pergunta = null;
+            intencao = null;
+            state.estado = 'working';
+            delete state.bloqueio;
+            delete state.perguntaNativa;
+        }
+        if (v.method === 'turn/completed' && p.turn.id === state.turno) {
+            // I-33 (D12): o erro nativo do turno (so presente em `failed`) vai ao estado, limitado e sem
+            // controle, para o observador classificar cota ou login perdido pelo proprio runtime.
+            const erro = (0, codex_controller_1.erroNativoDoTurno)(p.turn.error);
+            state.terminal = { metodo: 'turn/completed', threadId: p.threadId, turnId: p.turn.id, status: p.turn.status,
+                ...(erro ? { erro } : {}) };
+            state.estado = state.limitacao ? 'unavailable' : p.turn.status === 'interrupted' ? 'stopped' : p.turn.status === 'completed' ? 'completed' : 'failed';
+            delete state.bloqueio;
+            delete state.perguntaNativa;
+            pergunta = null;
+            setTimeout(() => child.stdin.end(), 250).unref();
+        }
+        salvar();
+    });
+    let ocupado = false;
+    const server = net.createServer({ allowHalfOpen: true }, socket => {
+        let texto = '';
+        socket.setTimeout(11000, () => socket.destroy());
+        socket.on('data', b => { texto += b; if (texto.length > 24000)
+            socket.destroy(); });
+        socket.on('end', async () => {
+            if (ocupado) {
+                socket.end(JSON.stringify({ ok: false, erro: 'runtime.unavailable: controller ocupado' }));
+                return;
+            }
+            ocupado = true;
+            try {
+                const r = JSON.parse(texto);
+                if (r.instancia !== state.instancia)
+                    throw new Error('runtime.unavailable: instância divergente');
+                let resultado;
+                if (r.operacao === 'consultar') {
+                    const lido = await rpc('thread/read', { threadId: state.sessionId, includeTurns: false });
+                    if (lido.thread.id !== state.sessionId || lido.thread.cwd !== state.cwd || lido.thread.path !== state.rollout)
+                        throw new Error('runtime.unavailable: identidade nativa divergente');
+                    resultado = state;
+                }
+                else if (r.operacao === 'enviar') {
+                    const e = r.dados;
+                    const identidade = e.sessao;
+                    if (e.contrato !== 'ork.session-answer/v1' || e.thread !== state.vinculo.thread || e.fase !== state.vinculo.fase ||
+                        identidade.sessionId !== state.sessionId || identidade.runtime !== 'codex' || identidade.cwd !== state.cwd ||
+                        identidade.instancia !== state.instancia || identidade.bloqueio !== state.bloqueio || !pergunta ||
+                        pergunta.params.turnId !== state.turno || pergunta.params.questions.length !== 1 ||
+                        !/^[a-f0-9-]{36}$/.test(e.envioId) || typeof e.resposta !== 'string' || e.resposta.length > 4096)
+                        throw new Error('runtime.unavailable: entrega não corresponde ao prompt nativo');
+                    const arquivo = `intent-${e.envioId}.json`;
+                    if (intencao || fs.existsSync(arquivo))
+                        throw new Error('runtime.unavailable: envio já iniciado; somente consultar recibo');
+                    const { resposta, ...semTexto } = e;
+                    intencao = semTexto;
+                    gravar(arquivo, intencao); // antes de qualquer escrita no transporte
+                    const q = pergunta.params.questions[0];
+                    send({ id: pergunta.id, result: { answers: { [q.id]: { answers: [resposta] } } } });
+                    await aguardar(() => fs.existsSync(`receipt-${e.envioId}.json`));
+                    resultado = true;
+                }
+                else if (r.operacao === 'parar') {
+                    const s = r.dados;
+                    if (!pergunta || state.estado !== 'blocked' || s.sessionId !== state.sessionId || s.instancia !== state.instancia ||
+                        s.cwd !== state.cwd || s.bloqueio !== state.bloqueio)
+                        throw new Error('runtime.unavailable: sessão não está bloqueada nesta instância');
+                    await rpc('turn/interrupt', { threadId: state.sessionId, turnId: state.turno });
+                    await aguardar(() => state.estado === 'stopped');
+                    resultado = true;
+                }
+                else
+                    throw new Error('runtime.unavailable: operação desconhecida');
+                socket.end(JSON.stringify({ ok: true, resultado }));
+            }
+            catch (e) {
+                socket.end(JSON.stringify({ ok: false, erro: e.message }));
+            }
+            finally {
+                ocupado = false;
+            }
+        });
+        socket.on('error', () => { });
+    });
+    child.on('close', (code, signal) => {
+        vivo = false;
+        clearInterval(vigia);
+        for (const p of chamadas.values())
+            p.reject(new Error('runtime.unavailable: processo encerrado'));
+        chamadas.clear();
+        state.processoEncerrado = { em: new Date().toISOString(), code, signal };
+        if (!state.terminal) {
+            state.estado = 'unavailable';
+            state.erro ??= 'runtime.unavailable: processo encerrou sem confirmação';
+        }
+        salvar();
+        server.close();
+    });
+    child.on('error', () => { if (child.pid === undefined)
+        state.runtimeNaoIniciado = true; state.erro = 'runtime.unavailable: falha ao iniciar app-server'; salvar(); server.close(); });
+    try {
+        if (pedido.contextoRuntime && (pedido.contextoRuntime.host !== 'codex' || pedido.contextoRuntime.threadId !== pedido.vinculo?.thread))
+            throw new Error('runtime.context.scope: contexto difere do vinculo do worker');
+        const contexto = pedido.contextoRuntime ? (0, runtime_context_1.validarContextoRuntime)(pedido.contextoRuntime, pedido.cwd) : undefined;
+        await rpc('initialize', { clientInfo: { name: 'ork_controller', version: '1' }, capabilities: { experimentalApi: true } });
+        // O launcher pode passar por env/node via exec mantendo o mesmo processo.
+        // Só fixar o executável após a resposta do app-server, sem aceitar outro PID/origem.
+        const inicial = state.processoRuntime;
+        const pronto = child.pid ? (0, codex_controller_1.identidadeDoProcesso)(child.pid) : undefined;
+        if (!inicial || !pronto || ['pid', 'uid', 'inicio', 'bootId', 'cwd'].some(chave => inicial[chave] !== pronto[chave]))
+            throw new Error('runtime.unavailable: identidade do runtime mudou durante initialize');
+        state.processoRuntime = pronto;
+        salvar();
+        send({ method: 'initialized' });
+        const auth = await rpc('account/read', { refreshToken: false });
+        if (auth.account?.type !== 'chatgpt')
+            throw new Error('runtime.unavailable: assinatura ChatGPT não comprovada; API paga recusada');
+        if (contexto) {
+            await rpc('skills/extraRoots/set', { extraRoots: [contexto.instalacao] });
+            const lista = await rpc('skills/list', { cwds: [pedido.cwd], forceReload: true });
+            const entradas = Array.isArray(lista?.data) ? lista.data.filter((e) => e.cwd === pedido.cwd) : [];
+            if (entradas.length !== 1 || !Array.isArray(entradas[0].skills) || !Array.isArray(entradas[0].errors) || entradas[0].errors.length ||
+                !entradas[0].skills.some((skill) => skill.name === 'orkastery-bootstrap' && skill.path === contexto.bootstrap && skill.enabled === true))
+                throw new Error('runtime.context.discovery: bootstrap instalado nao confirmado no cwd da fase');
+        }
+        const t = await rpc('thread/start', { cwd: pedido.cwd, model: pedido.model, modelProvider: 'openai',
+            sandbox: pedido.sandbox ?? 'workspace-write', approvalPolicy: 'never',
+            config: { ...(pedido.effort ? { model_reasoning_effort: pedido.effort } : {}),
+                ...(contexto ? { mcp_servers: { orkastery: contexto.servidor } } : {}) } });
+        if (t.thread.cwd !== pedido.cwd || !t.thread.path || !/^[a-f0-9-]{36}$/.test(t.thread.id))
+            throw new Error('runtime.unavailable: despacho sem identidade');
+        state.sessionId = t.thread.id;
+        state.rollout = t.thread.path;
+        const observado = await rpc('thread/read', { threadId: state.sessionId, includeTurns: false });
+        if (observado.thread.id !== state.sessionId || observado.thread.cwd !== state.cwd || observado.thread.path !== state.rollout)
+            throw new Error('runtime.unavailable: despacho não confirmado');
+        if (contexto) {
+            const status = await rpc('mcpServerStatus/list', { threadId: state.sessionId, limit: 100, detail: 'toolsAndAuthOnly' });
+            const mcp = Array.isArray(status?.data) ? status.data.filter((s) => s.name === 'orkastery') : [];
+            const nomes = mcp.length === 1 && mcp[0].tools && typeof mcp[0].tools === 'object'
+                ? Object.values(mcp[0].tools).map((tool) => tool?.name) : [];
+            if (!['ork_thread_status', 'ork_observe'].every(nome => nomes.includes(nome)))
+                throw new Error('runtime.context.discovery: ferramentas MCP do projeto nao confirmadas');
+            gravar('runtime-context.json', { projeto: contexto.projeto, instalacao: contexto.instalacao,
+                bootstrap: contexto.bootstrap, cwd: pedido.cwd, sessionId: state.sessionId, ferramentas: nomes });
+        }
+        await new Promise(resolve => server.listen('control.sock', () => { fs.chmodSync('control.sock', 0o600); resolve(); }));
+        const sandboxPolicy = pedido.sandbox === 'read-only' ? { type: 'readOnly' } : pedido.sandbox === 'danger-full-access'
+            ? { type: 'dangerFullAccess' } : { type: 'workspaceWrite', writableRoots: [pedido.cwd], networkAccess: false, excludeTmpdirEnvVar: false, excludeSlashTmp: false };
+        const reviewBase = pedido.reviewBaseBranch;
+        if (reviewBase !== undefined && (!/^[A-Za-z0-9][A-Za-z0-9._/-]{0,199}$/.test(reviewBase) || reviewBase.includes('..') || reviewBase.endsWith('/')))
+            throw new Error('runtime.unavailable: branch base invalida para review');
+        const turn = reviewBase
+            ? await rpc('review/start', { threadId: state.sessionId, target: { type: 'baseBranch', branch: reviewBase }, delivery: 'inline' })
+            : await rpc('turn/start', { threadId: state.sessionId, model: pedido.model ?? t.model, approvalPolicy: 'never', sandboxPolicy,
+                input: [{ type: 'text', text: pedido.prompt, text_elements: [] }], effort: pedido.effort,
+                ...(pedido.outputSchema ? { outputSchema: pedido.outputSchema } : {}),
+                ...(pedido.colaboracao ? { collaborationMode: { mode: pedido.colaboracao, settings: { model: t.model, reasoning_effort: pedido.effort ?? null, developer_instructions: null } } } : {}) });
+        if (reviewBase && (!turn?.turn?.id || typeof turn.turn.id !== 'string'))
+            throw new Error('runtime.unavailable: review nativo sem identidade de turno');
+        if (reviewBase && turn.reviewThreadId !== state.sessionId)
+            throw new Error('runtime.unavailable: review inline mudou a identidade da thread');
+        state.turno = turn.turn.id;
+        state.pronto = true;
+        salvar();
+    }
+    catch (e) {
+        state.estado = 'unavailable';
+        state.erro = e.message;
+        salvar();
+        child.stdin.end();
+        server.close();
+    }
+}
+if (require.main === module) {
+    (process.argv[2] === '--rpc' ? cliente() : servidor()).catch(() => { process.exitCode = 1; });
+}

package/dist/adapters/codex-controller.js

@@ -0,0 +1,252 @@
+"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.LIMITE_MENSAGEM_ERRO_NATIVO = void 0;
+exports.identidadeDoProcesso = identidadeDoProcesso;
+exports.processoTerminou = processoTerminou;
+exports.erroNativoDoTurno = erroNativoDoTurno;
+exports.erroNativoValido = erroNativoValido;
+exports.conferirDiretorio = conferirDiretorio;
+exports.lerEstadoController = lerEstadoController;
+exports.controleDoController = controleDoController;
+exports.despacharComController = despacharComController;
+exports.encerrarController = encerrarController;
+/** Controller criado pelo despacho, nunca descoberto por PID ou resume de outra sessão. */
+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 playbook_contracts_1 = require("../playbook-contracts");
+/** Só captura PIDs obtidos do spawn próprio ou do próprio worker, nunca descoberta por nome. */
+function identidadeDoProcesso(pid) {
+    const base = `/proc/${pid}`, st = fs.readFileSync(`${base}/stat`, 'utf8');
+    return { pid, uid: fs.statSync(base).uid, inicio: st.slice(st.lastIndexOf(')') + 2).split(' ')[19],
+        bootId: fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim(), executavel: fs.readlinkSync(`${base}/exe`), cwd: fs.readlinkSync(`${base}/cwd`) };
+}
+function processoTerminou(p) {
+    if (!p)
+        return false;
+    try {
+        const st = fs.readFileSync(`/proc/${p.pid}/stat`, 'utf8'), campos = st.slice(st.lastIndexOf(')') + 2).split(' ');
+        const boot = fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim();
+        // Zombie é terminal, embora /proc ainda espere o reaper; não existe sinalização aqui.
+        return boot !== p.bootId || campos[19] !== p.inicio || campos[0] === 'Z';
+    }
+    catch (e) {
+        return e.code === 'ENOENT';
+    }
+}
+exports.LIMITE_MENSAGEM_ERRO_NATIVO = 300;
+const CODIGO_ERRO_NATIVO = /^[A-Za-z0-9_]{1,64}$/;
+function erroNativoDoTurno(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return null;
+    const o = v;
+    const info = o.codexErrorInfo;
+    const bruto = typeof info === 'string' ? info : info && typeof info === 'object' && !Array.isArray(info) ? Object.keys(info)[0] ?? '' : '';
+    const codigo = bruto.replace(/[^A-Za-z0-9_]/g, '').slice(0, 64) || null;
+    const mensagem = typeof o.message === 'string'
+        ? Array.from(o.message.replace(/\p{Cc}/gu, ' ')).slice(0, exports.LIMITE_MENSAGEM_ERRO_NATIVO).join('').trim() : '';
+    return codigo || mensagem ? { codigo, mensagem } : null;
+}
+/** Forma exata gravada pelo worker; qualquer outra coisa no `state.json` e recusada pelo sensor. */
+function erroNativoValido(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return false;
+    const o = v;
+    return Object.keys(o).every(k => k === 'codigo' || k === 'mensagem') &&
+        (o.codigo === null || (typeof o.codigo === 'string' && CODIGO_ERRO_NATIVO.test(o.codigo))) &&
+        typeof o.mensagem === 'string' && Array.from(o.mensagem).length <= exports.LIMITE_MENSAGEM_ERRO_NATIVO && !/\p{Cc}/u.test(o.mensagem) &&
+        (o.codigo !== null || o.mensagem !== '');
+}
+const worker = () => path.join(__dirname, 'codex-controller-worker.js');
+function conferirDiretorio(dir) {
+    const st = fs.lstatSync(dir);
+    if (!st.isDirectory() || st.isSymbolicLink() || st.uid !== process.getuid?.() || (st.mode & 0o077)) {
+        throw new Error('runtime.unavailable: IPC exige diretório privado 0700 do uid autenticado');
+    }
+}
+function lerEstadoController(dir) {
+    conferirDiretorio(dir);
+    return JSON.parse(fs.readFileSync(path.join(dir, 'state.json'), 'utf8'));
+}
+function rpcController(dir, instancia, operacao, dados, timeout = 12000) {
+    conferirDiretorio(dir);
+    const r = (0, node_child_process_1.spawnSync)(process.execPath, [worker(), '--rpc'], { cwd: dir, encoding: 'utf8', timeout: Math.max(1, Math.floor(timeout)),
+        input: JSON.stringify({ instancia, operacao, dados }), maxBuffer: 1024 * 1024 });
+    if (r.status !== 0)
+        throw new Error('runtime.unavailable: controller não respondeu; não reenviar');
+    const out = JSON.parse(r.stdout);
+    if (!out.ok)
+        throw new Error(out.erro ?? 'runtime.unavailable: controller recusou');
+    return out.resultado;
+}
+function controleDoController(dir, vinculo, sessionId, cwd) {
+    const inicial = lerEstadoController(dir);
+    if (inicial.sessionId !== sessionId || inicial.cwd !== cwd ||
+        JSON.stringify(inicial.vinculo) !== JSON.stringify(vinculo))
+        throw new Error('runtime.unavailable: vínculo de despacho divergente');
+    const consultar = (orcamentoMs = 12000) => {
+        try {
+            const salvo = lerEstadoController(dir);
+            if (!salvo.terminal && !salvo.processoEncerrado && orcamentoMs <= 0)
+                return { ok: false, sessoes: [] };
+            const s = salvo.terminal || salvo.processoEncerrado ? salvo : rpcController(dir, inicial.instancia, 'consultar', undefined, Math.min(12000, orcamentoMs));
+            if (s.instancia !== inicial.instancia || s.sessionId !== sessionId || s.cwd !== cwd)
+                return { ok: false, sessoes: [] };
+            return { ok: true, sessoes: [{ sessionId, runtime: 'codex', cwd, instancia: s.instancia,
+                        estado: s.estado, bloqueio: s.bloqueio, ...{ perguntaNativa: s.perguntaNativa, limitacao: s.limitacao } }] };
+        }
+        catch {
+            return { ok: false, sessoes: [] };
+        }
+    };
+    return { consultar,
+        enviar: e => { rpcController(dir, inicial.instancia, 'enviar', e); },
+        confirmar: e => {
+            if (!/^[a-f0-9-]{36}$/.test(e.envioId))
+                return null;
+            const file = path.join(dir, `receipt-${e.envioId}.json`);
+            return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : null;
+        },
+        parar: s => { try {
+            rpcController(dir, inicial.instancia, 'parar', s);
+            return consultar().sessoes[0]?.estado === 'stopped';
+        }
+        catch {
+            return false;
+        } }, };
+}
+function despacharComController(pedido, env) {
+    const comando = ['codex', 'app-server', '--listen', 'stdio://'];
+    const vazio = { comando, sessionId: null, verificada: false, stdout: '', stderr: '' };
+    if (!pedido.vinculo || (0, node_crypto_1.createHash)('sha256').update(pedido.prompt).digest('hex') !== pedido.vinculo.promptSha256) {
+        return { ...vazio, ok: false, erro: 'runtime.unavailable: prompt não corresponde ao vínculo do despacho' };
+    }
+    // I-33 (D2): o worker herda este env inteiro; ele precisa carregar o CODEX_HOME do perfil do
+    // pedido, senao o turno rodaria e seria reverificado por outra conta.
+    if (pedido.perfil && env.CODEX_HOME !== pedido.perfil.codexHome)
+        return { ...vazio, ok: false, erro: 'runtime.unavailable: CODEX_HOME do despacho diverge do perfil do pedido' };
+    if (pedido.outputSchema !== undefined) {
+        try {
+            (0, playbook_contracts_1.validarSchemaPlaybook)(pedido.outputSchema);
+        }
+        catch {
+            return { ...vazio, ok: false, erro: 'runtime.unavailable: output schema invalido' };
+        }
+    }
+    if (pedido.dryRun)
+        return { ...vazio, ok: true };
+    const duracaoMaximaMs = pedido.duracaoMaximaMs ?? 6 * 60 * 60 * 1000;
+    if (!Number.isSafeInteger(duracaoMaximaMs) || duracaoMaximaMs < 1 || duracaoMaximaMs > 24 * 60 * 60 * 1000)
+        return { ...vazio, ok: false, erro: 'runtime.unavailable: duração máxima inválida' };
+    const instancia = (0, node_crypto_1.randomUUID)();
+    const limite = Date.now() + (pedido.esperaMs ?? 30000);
+    const dir = path.join(pedido.logDir ?? pedido.cwd, `controller-${(0, node_crypto_1.randomUUID)()}`);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const bootstrap = path.join(dir, 'bootstrap.json');
+    fs.writeFileSync(path.join(dir, 'launch.json'), JSON.stringify({ contrato: 'ork.controller-launch/v1', instancia, vinculo: pedido.vinculo, cwd: pedido.cwd, criadoEm: new Date().toISOString() }), { flag: 'wx', mode: 0o600 });
+    fs.writeFileSync(bootstrap, JSON.stringify({ pedido, instancia, prazoInicial: new Date(limite).toISOString(), duracaoMaximaMs }), { mode: 0o600, flag: 'wx' });
+    const fd = fs.openSync(bootstrap, 'r');
+    try {
+        const child = (0, node_child_process_1.spawn)(process.execPath, [worker()], { cwd: dir, env, detached: true, stdio: [fd, 'ignore', 'ignore'] });
+        child.on('error', () => { });
+        if (child.pid) {
+            let processoController;
+            try {
+                processoController = identidadeDoProcesso(child.pid);
+            }
+            catch { /* worker pode ter saído; referência nunca é perdida */ }
+            fs.writeFileSync(path.join(dir, 'process-launch.json'), JSON.stringify({ instancia, pid: child.pid, processoController }), { mode: 0o600, flag: 'wx' });
+        }
+        child.unref();
+    }
+    finally {
+        fs.closeSync(fd);
+        fs.unlinkSync(bootstrap);
+    }
+    while (Date.now() < limite) {
+        if (fs.existsSync(path.join(dir, 'state.json'))) {
+            const s = lerEstadoController(dir);
+            if (s.erro)
+                return { ...vazio, ok: false, erro: s.erro, controlador: dir };
+            if (s.pronto)
+                return { ...vazio, ok: true, sessionId: s.sessionId, verificada: true, controlador: dir };
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+    }
+    solicitarEncerramento(dir, instancia);
+    return { ...vazio, ok: false, erro: 'runtime.unavailable: controller sem confirmação do despacho; encerramento solicitado, referência preservada', controlador: dir };
+}
+function solicitarEncerramento(dir, instancia) {
+    const file = path.join(dir, 'stop-request.json'), value = { instancia, solicitadoEm: new Date().toISOString() };
+    try {
+        fs.writeFileSync(file, JSON.stringify(value), { mode: 0o600, flag: 'wx' });
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+        if (JSON.parse(fs.readFileSync(file, 'utf8')).instancia !== instancia)
+            throw new Error('runtime.unavailable: pedido de encerramento divergente');
+    }
+}
+/** Recuperação exata por referência do despacho. Nunca signal/resume/descoberta de sessão. */
+function encerrarController(dir, vinculo, instancia, esperaMs = 10000) {
+    conferirDiretorio(dir);
+    const launch = JSON.parse(fs.readFileSync(path.join(dir, 'launch.json'), 'utf8'));
+    if (launch.instancia !== instancia || JSON.stringify(launch.vinculo) !== JSON.stringify(vinculo))
+        throw new Error('runtime.unavailable: vínculo do encerramento divergente');
+    solicitarEncerramento(dir, instancia);
+    const fim = performance.now() + esperaMs;
+    let state;
+    do {
+        try {
+            state = lerEstadoController(dir);
+        }
+        catch { /* bootstrap ainda não observado */ }
+        if (state && state.instancia !== instancia)
+            throw new Error('runtime.unavailable: instância do encerramento divergente');
+        if (state && processoTerminou(state.processoController) && (processoTerminou(state.processoRuntime) || state.runtimeNaoIniciado === true && state.runtimePid === undefined && !!state.processoEncerrado)) {
+            const result = { ok: true, instancia, sessionId: state.sessionId, processoController: state.processoController,
+                processoRuntime: state.processoRuntime, runtimeNaoIniciado: state.runtimeNaoIniciado === true,
+                evidencia: state.runtimeNaoIniciado ? 'worker capturado terminal; ChildProcess confirmou falha de spawn sem PID de runtime' : 'ambas identidades capturadas no spawn estão terminais; sem sinal genérico', observadoEm: new Date().toISOString() };
+            fs.writeFileSync(path.join(dir, 'processes-ended.json'), JSON.stringify(result), { mode: 0o600 });
+            return result;
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+    } while (performance.now() < fim);
+    return { ok: false, instancia, sessionId: state?.sessionId ?? null, controlador: dir,
+        evidencia: 'runtime.unavailable: encerramento pendente; referência preservada para inspeção, nenhum sinal ou resume' };
+}