@orkastery/cli 0.2.0 → 0.4.1

package/dist/thread.js

@@ -48,10 +48,13 @@ exports.gravarThread = gravarThread;
 exports.idDisponivel = idDisponivel;
 exports.criarWorktree = criarWorktree;
 exports.novaThread = novaThread;
+exports.exigirVarianteCompativel = exigirVarianteCompativel;
 exports.blocoDaThread = blocoDaThread;
 exports.pausaNaThread = pausaNaThread;
 exports.pausasDaThread = pausasDaThread;
+exports.canalDaSessao = canalDaSessao;
 exports.resumoDaThread = resumoDaThread;
+exports.threadsDaListagem = threadsDaListagem;
 exports.tabelaDeThreads = tabelaDeThreads;
 exports.exigirFase = exigirFase;
 const fs = __importStar(require("node:fs"));
@@ -60,15 +63,21 @@ const ciclos_1 = require("./ciclos");
 const modos_1 = require("./modos");
 const manifest_1 = require("./manifest");
 const slug_1 = require("./slug");
+const types_1 = require("./types");
 const util_1 = require("./util");
 const ledger_1 = require("./ledger");
+const estado_thread_1 = require("./estado-thread");
+const creation_operation_store_1 = require("./creation-operation-store");
+const horario_1 = require("./horario");
+const maquina_1 = require("./maquina");
+const conducao_texto_1 = require("./conducao-texto");
 /** Diretorio de threads do projeto. */
 function dirThreads(raiz) {
-    return path.join((0, manifest_1.dirEstado)(raiz), 'threads');
+    return path.join((0, manifest_1.dirEstado)((0, estado_thread_1.raizDoEstado)(raiz)), 'threads');
 }
 /** Diretorio de uma thread. */
 function dirThread(raiz, id) {
-    return path.join(dirThreads(raiz), id);
+    return (0, estado_thread_1.estadoCanonico)(raiz, id);
 }
 /** Caminho do `thread.json`. */
 function caminhoThread(raiz, id) {
@@ -96,7 +105,7 @@ function lerThread(raiz, id) {
 /** Grava a thread, sempre atualizando o carimbo de alteracao. */
 function gravarThread(raiz, thread) {
     thread.atualizadaEm = (0, util_1.agora)();
-    (0, util_1.gravarJson)(caminhoThread(raiz, thread.id), thread);
+    (0, creation_operation_store_1.writeCreationJson)(caminhoThread(raiz, thread.id), thread);
 }
 /** Carimba a base da thread: branch e commit reais no momento da criacao. */
 function carimbarBase(raiz) {
@@ -148,10 +157,33 @@ function criarWorktree(carregado, id, slug, opcoes = {}) {
     if (!criada) {
         throw new Error(`worktree nao apareceu em \`git worktree list\` apos a criacao: ${dir}`);
     }
+    (0, estado_thread_1.vincularEstado)(raiz, id, dir);
     return { dir, branch };
 }
 /** Cria a thread: valida modo contra o manifesto, gera o slug e carimba a base. */
 function novaThread(carregado, opcoes) {
+    if (opcoes.dryRun)
+        return criarThreadSerializada(carregado, opcoes);
+    return (0, creation_operation_store_1.withCreationLock)((0, estado_thread_1.raizDoEstado)(carregado.raiz), 'threads', () => criarThreadSerializada(carregado, opcoes));
+}
+/**
+ * I-42 (D12): variante que redesenha blocos nao cabe num modo de bloco unico e parcial.
+ *
+ * Regra por desenho, nao por nome: `#Fast` tem um bloco so, com uma fase, e `gap` sobre ele
+ * apagaria o ciclo inteiro, enquanto `goal-plan` seria um no-op silencioso. A recusa sai antes
+ * de aplicar a variante, com o par variante-modo na mensagem. O `#Auto`, que tambem tem um bloco
+ * so mas percorre as seis fases, continua aceitando as duas, porque nelas ha o que redesenhar.
+ */
+function exigirVarianteCompativel(variante, def) {
+    if (!(0, ciclos_1.definicaoDaVariante)(variante).mudaBlocos)
+        return;
+    const [unico, ...resto] = def.blocos;
+    if (unico && resto.length === 0 && unico.fases.length < types_1.FASES.length) {
+        throw new Error(`o ciclo ${variante} redesenha os blocos e o modo ${def.tag} tem um bloco so ` +
+            `(${unico.fases.join('-')}): crie a thread sem --ciclo ou escolha um modo de ciclo completo`);
+    }
+}
+function criarThreadSerializada(carregado, opcoes) {
     const { raiz, manifesto } = carregado;
     const permitidos = manifesto.conduction.allowed_modes;
     if (!permitidos.includes(opcoes.modo)) {
@@ -167,6 +199,8 @@ function novaThread(carregado, opcoes) {
     const variante = opcoes.variante ?? null;
     // A variante muda o desenho dos blocos ANTES do slug: a parte 3 do slug vem do
     // primeiro bloco, entao um ciclo `goal-plan` ja nasce com o slug `f12`.
+    if (variante)
+        exigirVarianteCompativel(variante, def);
     const blocos = (0, ciclos_1.aplicarVariante)(def.blocos, variante);
     if (variante) {
         const dv = (0, ciclos_1.definicaoDaVariante)(variante);
@@ -183,15 +217,42 @@ function novaThread(carregado, opcoes) {
     else if (opcoes.branch) {
         throw new Error('--branch so vale com --ciclo merge-branch');
     }
-    const { id, assunto } = opcoes.dryRun
-        ? { id: `${abbrev}-${assuntoBruto}`, assunto: assuntoBruto }
-        : idDisponivel(raiz, abbrev, assuntoBruto);
+    const reservation = opcoes.reservation;
+    const operation = reservation ? (0, creation_operation_store_1.readCreationOperation)(raiz, reservation.operationId, reservation.principal) : null;
+    if (operation && (!operation.reserved.threadIds.includes(reservation.threadId)
+        || !reservation.threadId.startsWith(abbrev + '-') || !operation.reserved.ticketId
+        || operation.request.mode !== opcoes.modo || ['compensating', 'compensated', 'compensation_failed'].includes(operation.state)
+        || opcoes.criarWorktree || opcoes.worktree || opcoes.variante || opcoes.slug || opcoes.dryRun)) {
+        throw new Error('creation.conflict: reserva de thread incompatível');
+    }
+    const origin = operation ? { operationId: operation.operationId, ticketId: operation.reserved.ticketId, requestHash: operation.requestHash } : undefined;
+    if (reservation && fs.existsSync(caminhoThread(raiz, reservation.threadId))) {
+        const existing = lerThread(raiz, reservation.threadId);
+        if (existing.creationOrigin?.operationId !== origin.operationId || existing.creationOrigin?.ticketId !== origin.ticketId
+            || existing.creationOrigin?.requestHash !== origin.requestHash || existing.modo !== opcoes.modo || existing.nome !== opcoes.nome) {
+            throw new Error('creation.conflict: thread reservada pertence a outra intenção');
+        }
+        if (!(0, ledger_1.lerLedger)(dirThread(raiz, existing.id)).some((event) => event.tipo === ledger_1.TIPOS_DE_EVENTO.threadCriada)) {
+            (0, ledger_1.registrar)(dirThread(raiz, existing.id), existing.id, ledger_1.TIPOS_DE_EVENTO.threadCriada, { creationOrigin: origin, recovered: true });
+        }
+        return { thread: existing, gravada: false };
+    }
+    if (reservation && fs.existsSync(dirThread(raiz, reservation.threadId))
+        && fs.readdirSync(dirThread(raiz, reservation.threadId)).some((name) => !/^\.thread\.json\..+\.tmp$/.test(name))) {
+        throw new Error('creation.conflict: diretório reservado sem origem confirmada');
+    }
+    const { id, assunto } = reservation
+        ? { id: reservation.threadId, assunto: reservation.threadId.slice(abbrev.length + 1) }
+        : opcoes.dryRun
+            ? { id: `${abbrev}-${assuntoBruto}`, assunto: assuntoBruto }
+            : idDisponivel(raiz, abbrev, assuntoBruto);
     const slug = opcoes.slug ?? (0, slug_1.montarSlug)(abbrev, assunto, blocos[0].slugFases);
     // O override `--slug` do builder tambem passa pela regex canonica.
     if (!(0, slug_1.slugValido)(slug)) {
         throw new Error(`slug invalido: "${slug}" (regex canonica: ${slug_1.REGEX_SLUG.source})`);
     }
     const thread = {
+        ...(origin ? { creationOrigin: origin } : {}),
         id,
         slug,
         nome: opcoes.nome,
@@ -204,9 +265,13 @@ function novaThread(carregado, opcoes) {
         criadaEm: (0, util_1.agora)(),
         atualizadaEm: (0, util_1.agora)(),
         projeto: { name: manifesto.project.name, abbrev },
+        maquina: (0, maquina_1.nomeDaMaquina)(),
+        ...(opcoes.roadmap ? { roadmap: opcoes.roadmap } : {}),
         base: carimbarBase(raiz),
         worktree: opcoes.worktree ?? null,
         sessoes: [],
+        ...(opcoes.exigeRuntimeDiferente === true ? { exigeRuntimeDiferente: true } : {}),
+        ...(opcoes.doneWhen && opcoes.doneWhen.length > 0 ? { doneWhen: opcoes.doneWhen } : {}),
         decisoes: [],
         claims: [],
         leases: [],
@@ -235,6 +300,7 @@ function novaThread(carregado, opcoes) {
     }
     gravarThread(raiz, thread);
     (0, ledger_1.registrar)(dirThread(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.threadCriada, {
+        ...(origin ? { creationOrigin: origin } : {}),
         slug,
         modo: opcoes.modo,
         tag: def.tag,
@@ -245,6 +311,8 @@ function novaThread(carregado, opcoes) {
         worktree: thread.worktree,
         variante,
         branchDeOrigem: opcoes.branch ?? null,
+        maquina: thread.maquina,
+        ...(thread.roadmap ? { roadmap: thread.roadmap } : {}),
     });
     if (worktreeCriada) {
         (0, ledger_1.registrar)(dirThread(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeCriada, {
@@ -280,48 +348,94 @@ function pausasDaThread(thread) {
     return thread.blocos.filter((b) => b.pausa).length;
 }
 /** Texto do resumo de uma thread recem-criada ou consultada. */
-function resumoDaThread(thread) {
+/** I-36 (T10): o canal de origem de uma sessao; a de antes do campo le como `desconhecido`, nunca `cli`. */
+function canalDaSessao(s) {
+    return s.canal ?? 'desconhecido';
+}
+function resumoDaThread(thread, conducao) {
     const def = (0, modos_1.definicaoDoModo)(thread.modo);
     const linhas = [];
     linhas.push(`  id        ${thread.id}`);
     linhas.push(`  slug      ${thread.slug}`);
     linhas.push(`  nome      ${thread.nome}`);
-    linhas.push(`  modo      ${def.tag} (${pausasDaThread(thread)} pausas humanas)`);
+    linhas.push(`  modo      ${def.tag} (${pausasDaThread(thread)} pausas humanas previstas)`);
     linhas.push(`  ciclo     ${thread.variante ?? 'padrao do modo'}`);
     linhas.push(`  fase      ${thread.faseAtual}`);
     linhas.push(`  status    ${thread.status}`);
     linhas.push(`  base      ${thread.base.branch} @ ${thread.base.commit.slice(0, 8)}`);
     linhas.push(`  worktree  ${thread.worktree ?? '(raiz do projeto)'}`);
+    // I-36 (T17): quem passa a leitura da conducao ve a linha unica; sem ela o resumo fica como era.
+    if (conducao !== undefined)
+        linhas.push(`  conducao  ${conducao ? (0, conducao_texto_1.linhaDeConducao)(conducao) : 'ninguem conduz agora'}`);
+    // I-43 (D4, viga a): a exigencia so aparece quando existe, para nao poluir o resumo
+    // das threads que nao a declararam.
+    if (thread.exigeRuntimeDiferente === true) {
+        linhas.push('  validacao CHECK em runtime diferente do GO (exigido pela thread)');
+    }
+    // I-43 (D4, viga b): o criterio aparece COM o comando. Mostrar so o criterio seria
+    // reproduzir a prosa do envelope numa tela nova.
+    if (thread.doneWhen && thread.doneWhen.length > 0) {
+        linhas.push(`  pronto quando (${thread.doneWhen.length} criterio(s) executaveis)`);
+        for (const d of thread.doneWhen)
+            linhas.push(`    ${d.criterio}\n      $ ${d.comando}`);
+    }
     if (thread.score) {
         linhas.push(`  score     ${thread.score.valor}/5 por ${thread.score.avaliadoPor} ` +
-            `(${thread.score.regime}) em ${thread.score.avaliadoEm}`);
+            `(${thread.score.regime}) em ${(0, horario_1.formatarDataHoraRotulada)(thread.score.avaliadoEm)}`);
     }
-    linhas.push('  blocos');
+    linhas.push('  blocos previstos');
     for (const b of thread.blocos) {
-        const marca = b.pausa ? `pausa: ${b.pausaSobre}` : 'sem pausa (decisao autonoma no ledger)';
+        const marca = b.pausa ? `pausa prevista: ${b.pausaSobre}` : 'sem pausa humana prevista';
         linhas.push(`    ${b.slugFases.padEnd(6)} ${b.fases.join('-').padEnd(18)} ${marca}`);
     }
     return linhas.join('\n');
 }
+/**
+ * As threads de `ork thread list`, ja filtradas.
+ *
+ * I-43 (D8): o DEFAULT mostra o que NAO esta fechado, e nao "so as abertas".
+ * O GOAL pediu "so abertas", e a medida corrigiu o pedido: existe thread `pausada`
+ * em disco, e um default que a esconde esconde justamente a que mais pede atencao.
+ *
+ * O custo medido era o default: 137 linhas para as 31 que interessavam, e 71 delas
+ * (52 por cento) eram `Sessao adotada claude-bg <uuid>`, lixo do mecanismo de adocao.
+ * Quem pagava era quem nao sabia que existia flag.
+ */
+function threadsDaListagem(raiz, opcoes = {}) {
+    return listarIds(raiz)
+        .map((id) => lerThread(raiz, id))
+        .filter((t) => opcoes.todas === true || t.status !== 'fechada')
+        .map((t) => ({
+        id: t.id,
+        slug: t.slug,
+        modo: String(t.modo),
+        tag: (0, modos_1.tagDoModo)(t.modo),
+        fase: t.faseAtual,
+        status: t.status,
+        pausas: pausasDaThread(t),
+        sessoes: t.sessoes.length,
+    }));
+}
 /** Tabela de `ork thread list`. */
-function tabelaDeThreads(raiz) {
-    const ids = listarIds(raiz);
-    if (ids.length === 0) {
-        return 'Nenhuma thread em .orkastery/threads. Crie uma com: ork thread new "<nome>" --modo default';
+function tabelaDeThreads(raiz, opcoes = {}) {
+    const linhas = threadsDaListagem(raiz, opcoes);
+    if (linhas.length === 0) {
+        // A divida paga aqui: a mensagem sugeria `--modo default`, um modo que
+        // `parseModo` recusa, e e a origem provavel das 3 threads com `modo: default`
+        // gravadas em disco. A sugestao agora e um modo que existe.
+        const vazio = opcoes.todas === true
+            ? 'Nenhuma thread em .orkastery/threads.'
+            : 'Nenhuma thread aberta ou pausada (use --todas para ver as fechadas).';
+        return `${vazio} Crie uma com: ork thread new "<nome>" --modo ${modos_1.ORDEM_DOS_MODOS[0]}`;
     }
-    const linhas = ids.map((id) => {
-        const t = lerThread(raiz, id);
-        return [
-            t.id,
-            t.slug,
-            (0, modos_1.tagDoModo)(t.modo),
-            t.faseAtual,
-            t.status,
-            String(pausasDaThread(t)),
-            String(t.sessoes.length),
-        ];
-    });
-    return (0, util_1.tabela)(['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'PAUSAS', 'SESSOES'], linhas);
+    const corpo = linhas.map((l) => [
+        l.id, l.slug, l.tag, l.fase, l.status, String(l.pausas), String(l.sessoes),
+    ]);
+    const t = (0, util_1.tabela)(['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'PAUSAS', 'SESSOES'], corpo);
+    if (opcoes.todas === true)
+        return t;
+    const fechadas = listarIds(raiz).length - linhas.length;
+    return fechadas > 0 ? `${t}\n\n  ${fechadas} fechada(s) omitida(s). Use --todas para ver todas.` : t;
 }
 /** Fase valida e pertencente ao ciclo da thread. */
 function exigirFase(thread, bruto) {

package/dist/tokens.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * `ork gate next`: o gate de tokens (visao unificada, secao 3.6).
+ * `ork gate next`: o gate de tokens (guia: docs/guias/memoria-e-handoff.md).
  *
  * Ao fim de cada fase, ANTES de despachar o proximo passo, o `ork` mede a lotacao da
  * janela da sessao atual e decide entre continuar na MESMA sessao ou abrir uma NOVA.

package/dist/util.js

@@ -50,18 +50,20 @@ const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 /** Executa um comando capturando saida, sem shell (argumentos vao como array). */
-function exec(cmd, args, cwd, timeoutMs = 120000) {
+function exec(cmd, args, cwd, timeoutMs = 120000, env = process.env) {
     const r = (0, node_child_process_1.spawnSync)(cmd, args, {
         cwd,
         encoding: 'utf8',
         timeout: timeoutMs,
-        env: process.env,
+        env,
     });
     return {
         ok: r.status === 0,
         code: r.status ?? -1,
         stdout: (r.stdout ?? '').toString(),
         stderr: (r.stderr ?? '').toString(),
+        signal: r.signal ?? null,
+        ...(r.error ? { error: r.error.code ?? r.error.message } : {}),
     };
 }
 /** O binario esta no PATH? */

package/dist/verify-sandbox.js

@@ -0,0 +1,265 @@
+"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.criarExecutorSandbox = criarExecutorSandbox;
+/** VERIFY interno sob sandbox Codex local, sem modelo e sem fallback não confinado.
+ * Contrato de escrita/rede, não de confidencialidade de leitura do filesystem.
+ * API síncrona: timeout rígido; não promete cancelamento reativo por AbortSignal.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_url_1 = require("node:url");
+const verify_1 = require("./verify");
+const MAX_OUTPUT = 1024 * 1024;
+/** Supervisor Linux fixo: subreaper recolhe também daemons/setsid.
+ * Nunca executa código de claim fora do sandbox. Python é infraestrutura local, sem pacotes. */
+const SUPERVISOR = String.raw `
+import ctypes, errno, json, os, selectors, signal, subprocess, sys, time
+p = json.load(sys.stdin)
+libc = ctypes.CDLL(None, use_errno=True)
+if libc.prctl(36, 1, 0, 0, 0) != 0:
+    raise OSError(ctypes.get_errno(), 'PR_SET_CHILD_SUBREAPER falhou')
+state = {'failure': None}
+def interrupted(_sig, _frame): state['failure'] = 'supervisor interrompido'
+signal.signal(signal.SIGTERM, interrupted)
+def cleanup():
+    deadline = time.monotonic() + 3
+    while True:
+        with open('/proc/self/task/' + str(os.getpid()) + '/children') as f:
+            children = [int(x) for x in f.read().split()]
+        # Filhos vivos ou zombies ainda não reaped: seus PIDs não podem ser reutilizados.
+        for pid in children:
+            try: os.kill(pid, signal.SIGKILL)
+            except ProcessLookupError: pass
+        try:
+            while True:
+                pid, _status = os.waitpid(-1, os.WNOHANG)
+                if pid == 0: break
+        except ChildProcessError: return True
+        if time.monotonic() >= deadline: return False
+        time.sleep(.005)
+stdout = bytearray(); stderr = bytearray(); code = -1
+try:
+    child = subprocess.Popen([p['bin'], *p['args']], cwd=p['cwd'], env=p['env'],
+        stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE, start_new_session=True)
+    selector = selectors.DefaultSelector()
+    selector.register(child.stdout, selectors.EVENT_READ, stdout)
+    selector.register(child.stderr, selectors.EVENT_READ, stderr)
+    deadline = time.monotonic() + p['timeoutMs']/1000
+    while True:
+        if state['failure']: break
+        if time.monotonic() >= deadline:
+            state['failure'] = 'timeout do sandbox'; break
+        if child.poll() is not None and not selector.get_map():
+            code = child.returncode; break
+        for key, _ in selector.select(.025):
+            data = os.read(key.fileobj.fileno(), 65536)
+            if not data: selector.unregister(key.fileobj); continue
+            if len(stdout)+len(stderr)+len(data) > p['maxOutput']:
+                state['failure'] = 'limite de saída excedido'; break
+            key.data.extend(data)
+except Exception as e: state['failure'] = 'sandbox indisponível: ' + str(e)
+finally:
+    cleanup_complete = cleanup()
+    if not cleanup_complete: state['failure'] = 'descendente do sandbox não encerrou no prazo'
+print(json.dumps({'code': -1 if state['failure'] else code,
+    'stdout': stdout.decode(errors='replace'), 'stderr': stderr.decode(errors='replace'), 'failure': state['failure'], 'cleanupComplete': cleanup_complete}))
+`;
+/** Somente WT e leaf scratch privado são graváveis; configuração e parent continuam readonly. */
+function estadoSandbox(worktree, scratch) {
+    const entries = [
+        { path: { type: 'special', value: { kind: 'root' } }, access: 'read' },
+        { path: { type: 'path', path: worktree }, access: 'write' },
+        { path: { type: 'path', path: scratch }, access: 'write' },
+    ];
+    // Metadados/configuração de host e estado canônico não pertencem ao comando testado.
+    for (const nome of ['.git', '.orkastery', '.codex', '.claude', '.agents']) {
+        const alvo = path.join(worktree, nome);
+        entries.push({ path: { type: 'path', path: alvo }, access: 'read' });
+    }
+    return {
+        permissionProfile: { type: 'managed', file_system: { type: 'restricted', entries }, network: 'restricted' },
+        sandboxCwd: (0, node_url_1.pathToFileURL)(worktree).href,
+        useLegacyLandlock: false,
+    };
+}
+function criarExecutorSandbox(opcoes) {
+    if (process.platform !== 'linux')
+        throw new Error('executor VERIFY sandbox disponível somente em Linux');
+    if (!path.isAbsolute(opcoes.worktree))
+        throw new Error('worktree deve ser absoluta');
+    const worktree = fs.realpathSync(opcoes.worktree);
+    if (!fs.statSync(worktree).isDirectory() || worktree === path.parse(worktree).root)
+        throw new Error('worktree inválida');
+    const original = fs.statSync(worktree);
+    const timeoutMs = opcoes.timeoutMs ?? 60_000;
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > verify_1.TIMEOUT_VERIFY_MS)
+        throw new Error('timeout sandbox fora do limite');
+    // Binário local aprovado da instalação; não procuramos executável fornecido pela claim.
+    const bin = fs.realpathSync('/usr/bin/codex');
+    const binStat = fs.statSync(bin);
+    const isolamento = fs.mkdtempSync(path.join(os.tmpdir(), 'ork-verify-config-'));
+    if (fs.realpathSync(isolamento) === worktree || fs.realpathSync(isolamento).startsWith(worktree + path.sep)) {
+        fs.rmdirSync(isolamento);
+        throw Error('scratch VERIFY deve ficar fora da worktree');
+    }
+    const isolamentoStat = fs.lstatSync(isolamento);
+    const identidadeIgual = (file, original) => {
+        const st = fs.lstatSync(file, { throwIfNoEntry: false });
+        return !!st && st.isDirectory() && !st.isSymbolicLink() && st.dev === original.dev && st.ino === original.ino && st.uid === original.uid;
+    };
+    const codexHome = path.join(isolamento, 'codex');
+    fs.mkdirSync(codexHome);
+    fs.writeFileSync(path.join(codexHome, 'config.toml'), '');
+    let fechado = false, consumidoresEncerrados = true, erroCleanup = '';
+    const fechar = () => {
+        if (fechado) {
+            if (erroCleanup)
+                throw Error(erroCleanup);
+            return;
+        }
+        if (erroCleanup)
+            throw Error(erroCleanup);
+        if (!consumidoresEncerrados)
+            throw Error('cleanup incompleto: consumidores não comprovadamente encerrados; isolamento preservado: ' + isolamento);
+        if (!identidadeIgual(isolamento, isolamentoStat))
+            throw Error('cleanup incompleto: isolamento substituído; preservado');
+        fechado = true;
+        fs.rmSync(isolamento, { recursive: true, force: false });
+    };
+    const executar = (nome, comando, cwd) => {
+        if (fechado)
+            throw new Error('executor sandbox fechado');
+        if (erroCleanup || !consumidoresEncerrados)
+            throw Error(erroCleanup || 'cleanup incompleto: consumidor pendente');
+        const atual = fs.statSync(worktree);
+        const atualBin = fs.statSync(bin);
+        if (fs.realpathSync(cwd) !== worktree || atual.dev !== original.dev || atual.ino !== original.ino ||
+            atualBin.dev !== binStat.dev || atualBin.ino !== binStat.ino)
+            throw new Error('escopo/binário do executor sandbox mudou');
+        if (!identidadeIgual(isolamento, isolamentoStat))
+            throw Error('isolamento sandbox mudou');
+        const scratch = fs.mkdtempSync(path.join(isolamento, 'scratch-'));
+        const scratchStat = fs.lstatSync(scratch);
+        const criados = [];
+        const home = path.join(scratch, 'home');
+        const tmp = path.join(scratch, 'tmp');
+        fs.mkdirSync(home);
+        fs.mkdirSync(tmp);
+        try {
+            // Diretórios vazios não aparecem no Git. Não criar arquivos sintéticos nem esconder untracked.
+            for (const nome of ['.git', '.orkastery', '.codex', '.claude', '.agents']) {
+                const file = path.join(worktree, nome);
+                let st = fs.lstatSync(file, { throwIfNoEntry: false });
+                if (!st) {
+                    fs.mkdirSync(file, { mode: 0o700 });
+                    st = fs.lstatSync(file);
+                    criados.push({ file, stat: st });
+                }
+                if (st.isSymbolicLink() || !(st.isDirectory() || (nome === '.git' && st.isFile() && st.nlink === 1)))
+                    throw Error('metadado protegido inesperado; objeto preservado: ' + nome);
+            }
+            for (const item of criados)
+                if (!identidadeIgual(item.file, item.stat))
+                    throw Error('metadado temporário mudou antes do lançamento');
+            const env = { PATH: '/usr/local/bin:/usr/bin:/bin', HOME: home, CODEX_HOME: codexHome,
+                TMPDIR: tmp, TMP: tmp, TEMP: tmp, LANG: 'C.UTF-8', CI: '1',
+                XDG_CACHE_HOME: path.join(home, '.cache'), npm_config_cache: path.join(home, '.npm') };
+            const args = ['sandbox', '--sandbox-state-json', JSON.stringify(estadoSandbox(worktree, scratch)),
+                '--sandbox-state-disable-network', '/bin/bash', '-c', comando];
+            consumidoresEncerrados = false;
+            const r = (0, node_child_process_1.spawnSync)('/usr/bin/python3', ['-c', SUPERVISOR], {
+                input: JSON.stringify({ bin, args, cwd: worktree, env, timeoutMs, maxOutput: MAX_OUTPUT }),
+                cwd: isolamento, env, encoding: 'utf8', maxBuffer: 4 * MAX_OUTPUT,
+                timeout: timeoutMs + 5_000, killSignal: 'SIGTERM',
+            });
+            let resultado;
+            try {
+                if (r.error || r.status !== 0)
+                    throw new Error(r.error?.message ?? `supervisor saiu ${r.status}`);
+                const v = JSON.parse(r.stdout);
+                if (!v || typeof v !== 'object')
+                    throw new Error('resposta inválida');
+                const x = v;
+                if (!Number.isInteger(x.code) || typeof x.stdout !== 'string' || typeof x.stderr !== 'string' ||
+                    !(x.failure === null || typeof x.failure === 'string') || typeof x.cleanupComplete !== 'boolean')
+                    throw new Error('resposta inválida');
+                resultado = x;
+                consumidoresEncerrados = resultado.cleanupComplete;
+            }
+            catch (e) {
+                resultado = { code: -1, stdout: '', stderr: r.stderr ?? '', failure: `falha fechada do sandbox: ${String(e)}`, cleanupComplete: false };
+            }
+            const stderr = resultado.stderr + (resultado.failure ? '\n' + resultado.failure : '');
+            const resumo = (resultado.stdout + '\n' + stderr).trim().split('\n').slice(-10).join('\n').slice(-800);
+            return { nome, comando, ok: resultado.code === 0 && !resultado.failure, code: resultado.code,
+                resumo, stdout: resultado.stdout, stderr, executor: 'codex-sandbox' };
+        }
+        finally {
+            if (!consumidoresEncerrados) {
+                erroCleanup = 'cleanup incompleto: consumidores não comprovadamente encerrados; temporários preservados: ' + isolamento;
+            }
+            else {
+                const erros = [];
+                for (const item of criados.reverse()) {
+                    try {
+                        if (!identidadeIgual(item.file, item.stat))
+                            throw Error('identidade mudou');
+                        // rmdir é a checagem atômica de vazio. Nunca recursive/force nos paths da WT.
+                        fs.rmdirSync(item.file);
+                    }
+                    catch {
+                        erros.push(path.basename(item.file));
+                    }
+                }
+                try {
+                    if (!identidadeIgual(isolamento, isolamentoStat) || !identidadeIgual(scratch, scratchStat))
+                        throw Error('scratch mudou');
+                    fs.rmSync(scratch, { recursive: true, force: false });
+                }
+                catch {
+                    erros.push('scratch');
+                }
+                if (erros.length)
+                    erroCleanup = 'cleanup incompleto: objetos substituídos ou não vazios preservados: ' + erros.join(', ') + '; isolamento preservado: ' + isolamento;
+            }
+            if (erroCleanup)
+                throw Error(erroCleanup);
+        }
+    };
+    return { executar, fechar };
+}