@orkastery/cli 0.4.3 → 0.5.0

package/dist/phase.js

@@ -43,11 +43,14 @@ exports.valoresDoPrompt = valoresDoPrompt;
 exports.montarPrompt = montarPrompt;
 exports.montarPromptComMemoria = montarPromptComMemoria;
 exports.hashDoPrompt = hashDoPrompt;
+exports.modoDaSessaoDoBloco = modoDaSessaoDoBloco;
 exports.slugDaSessao = slugDaSessao;
 exports.resolverDespacho = resolverDespacho;
 exports.dadosDoDespacho = dadosDoDespacho;
 exports.concluirDespacho = concluirDespacho;
 exports.prazoDaSessao = prazoDaSessao;
+exports.baselineDoDespachoNecessaria = baselineDoDespachoNecessaria;
+exports.garantirBaselineDoDespacho = garantirBaselineDoDespacho;
 exports.rodarFase = rodarFase;
 exports.tabelaDoLedger = tabelaDoLedger;
 exports.descreverSlug = descreverSlug;
@@ -64,6 +67,8 @@ const runtime_context_1 = require("./runtime-context");
 const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const board_1 = require("./board");
+const verify_1 = require("./verify");
 const session_watcher_1 = require("./session-watcher");
 const session_watcher_claude_1 = require("./session-watcher-claude");
 const runtimes_1 = require("./runtimes");
@@ -328,6 +333,20 @@ function schemaDeClaimsDoPacote() {
         throw new Error('runtime.unavailable: schema de claims nao encontrado no pacote');
     return JSON.parse(fs.readFileSync(arquivo, 'utf8'));
 }
+/**
+ * RM-037 (rm037defeito, defeito 2): o modo da sessao sai do BLOCO, nao da fase de entrada. O modo plano
+ * (codex em `collaborationMode: plan`; claude-bg sem Edit/Write e com MCP so de consulta) e o review
+ * nativo do codex (`review/start`) valem para a sessao inteira. Aplicados pela fase de entrada, o PLAN
+ * redespachado de um bloco GOAL..MASTER abria a sessao em modo plano e ela nao podia seguir para o GO
+ * (rollout 01a0ed23, 29/09/2026), e o CHECK de entrada no codex so revisava, sem SHIP nem MASTER. Os
+ * dois modos ficam para o bloco que termina na propria fase de entrada. Domicilio unico: `ork phase run`
+ * e o redespacho do `ork retry` leem daqui.
+ */
+function modoDaSessaoDoBloco(thread, fase) {
+    const bloco = (0, thread_1.blocoDaThread)(thread, fase);
+    const terminaNaEntrada = bloco.fases[bloco.fases.length - 1] === fase;
+    return { plano: fase === 'PLAN' && terminaNaEntrada, revisaoNativa: fase === 'CHECK' && terminaNaEntrada };
+}
 /** Slug da sessao que conduz esta fase, rotacionando quando o slug ja foi usado na thread. */
 function slugDaSessao(thread, fase) {
     const bloco = (0, thread_1.blocoDaThread)(thread, fase);
@@ -521,22 +540,100 @@ function registrarObservacao(ctx, sessao, dir, controlador, sensores) {
             origem: 'phase.dispatch', ...(controlador ? { controlador } : {}) });
     }
 }
+/**
+ * RM-037 (rm037defeito, defeito 1): o despacho precisa gravar a baseline antes de soltar o bloco? O codex
+ * roda em sandbox que so grava a worktree; o estado canonico fica fora dela, e `ork verify --baseline`
+ * de dentro da sessao morre em EROFS (rollouts 01a0ecff e 01a0ed16, 29/09/2026). A sessao parava antes
+ * do GO, porque a skill exige a baseline antes da primeira linha. Vale para o despacho real do codex
+ * com sandbox que nao grava o estado, num bloco que tem GO a partir da entrada, sem baseline gravada.
+ */
+function baselineDoDespachoNecessaria(carregado, threadId, opcoes) {
+    if (opcoes.dryRun)
+        return false;
+    const { raiz, manifesto } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    if (thread.status === 'fechada')
+        return false;
+    // Pedido que nem resolve o trio (runtime trocado sem modelo) recebe a recusa do proprio despacho.
+    let runtime;
+    try {
+        runtime = resolverDespacho(manifesto, opcoes, (0, setup_1.configDoBloco)((0, setup_1.lerSetup)(raiz), thread.modo, opcoes.fase)).runtime;
+    }
+    catch {
+        return false;
+    }
+    if (runtime !== 'codex' || manifesto.runtime.sandbox === 'danger-full-access')
+        return false;
+    const bloco = (0, thread_1.blocoDaThread)(thread, opcoes.fase);
+    if (!bloco.fases.slice(bloco.fases.indexOf(opcoes.fase)).includes('GO'))
+        return false;
+    return !(0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread.id)).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.baselineGravada);
+}
+/**
+ * Grava a baseline do despacho quando ela e necessaria, pela mesma `gravarBaseline` do CLI e fora do lock
+ * HITL. O despacho (`ork phase run`, e o redespacho do `ork retry` quando o fallback leva ao codex) chega
+ * aqui depois de passar por todos os portoes e RETENDO a conducao que tomou (B-1 e A-1r do CHECK 4): a
+ * baseline roda como reentrada dessa mesma conducao, sem `conducao_recusada` e sem soltar a reserva do dono
+ * ou a sessao bloqueada que a tomada sucedeu. A segunda passada do despacho usa a tomada retida.
+ */
+function garantirBaselineDoDespacho(carregado, threadId, opcoes, identidade) {
+    if (!baselineDoDespachoNecessaria(carregado, threadId, opcoes))
+        return;
+    try {
+        (0, verify_1.gravarBaseline)(carregado, threadId, undefined, { canal: opcoes.canal ?? (0, conducao_1.canalDoProcesso)(), correlacao: opcoes.correlacao ?? null, ...(identidade ? { identidade } : {}) }, 'phase.run');
+    }
+    catch (e) {
+        if (!(e instanceof conducao_1.ErroDeConducao))
+            throw e;
+    }
+}
 /** Despacha a fase pelo runtime adapter e registra tudo no ledger da thread. */
 function rodarFase(carregado, threadId, opcoes) {
-    const rodar = () => opcoes.dryRun ? rodarFaseSobLock(carregado, threadId, opcoes) :
-        (0, hitl_gates_1.comLockHitl)(carregado.raiz, threadId, () => rodarFaseSobLock(carregado, threadId, opcoes));
+    const rodar = (retida) => opcoes.dryRun ? rodarFaseSobLock(carregado, threadId, opcoes) :
+        (0, hitl_gates_1.comLockHitl)(carregado.raiz, threadId, () => rodarFaseSobLock(carregado, threadId, opcoes, retida));
     // I-36 (D2): `--esperar` espera a vez FORA do lock HITL (que serializa respostas do dono) e so
     // depois repete o pedido. Sem ele, a recusa sai na hora.
+    // RM-037 (defeito 3): a vaga do projeto espera do mesmo jeito, fora do lock, antes de repetir.
     const prazo = opcoes.esperarMs && opcoes.esperarMs > 0 && !opcoes.dryRun ? Date.now() + opcoes.esperarMs : null;
     for (;;) {
-        if (prazo)
+        if (prazo) {
             (0, conducao_1.esperarConducaoLivre)(carregado.raiz, threadId, Math.max(0, prazo - Date.now()));
-        const r = rodar();
-        if (r.motivo !== 'conducao.em-andamento' || !prazo || Date.now() >= prazo)
+            (0, board_1.esperarVaga)(carregado, threadId, Math.max(0, prazo - Date.now()));
+        }
+        let r = rodar();
+        // RM-037 (defeito 1; N3 e G2 do CHECK 2, B-1 e A-1r do CHECK 4): o despacho so pede a baseline depois de
+        // passar por todos os portoes, retendo a conducao que tomou (orfa liberada, sucessao feita, reserva
+        // usada). Ela e gravada aqui, fora do lock HITL (que e nao bloqueante e recusaria respostas do dono por
+        // minutos), como reentrada da tomada retida, e o despacho repete uma vez com ela. No MCP, que nao roda a
+        // suite, a pendencia volta como esta e a tomada ja foi devolvida.
+        const retida = r.retida;
+        if (retida) {
+            delete r.retida;
+            // A segunda passada converte a tomada em sessao ou a devolve; devolver de novo e inocuo, e o `finally`
+            // cobre tambem a excecao (lock HITL ocupado, por exemplo: R5-A1 do CHECK 5).
+            try {
+                garantirBaselineDoDespacho(carregado, threadId, opcoes, retida.identidade);
+                r = rodar(retida);
+            }
+            finally {
+                retida.devolver();
+            }
+        }
+        const esperavel = r.motivo === 'conducao.em-andamento' || r.motivo === 'concurrency.limite';
+        if (!esperavel || !prazo || Date.now() >= prazo)
             return r;
+        // S-5 do CHECK 3: a vaga pode ter sido tomada entre a espera e a tomada; espera um pouco antes de repetir.
+        if (r.motivo === 'concurrency.limite')
+            (0, conducao_1.dormir)(Math.min(2000, Math.max(0, prazo - Date.now())));
     }
 }
-function rodarFaseSobLock(carregado, threadId, opcoes) {
+function rodarFaseSobLock(carregado, threadId, opcoes, 
+/**
+ * A tomada que a primeira passada reteve para a baseline (CHECK 4). Com ela, esta e a repeticao: nao toma a
+ * conducao de novo e nao grava de novo os avisos da primeira passada (S-1 do CHECK 3).
+ */
+tomadaPrevia) {
+    const segundaPassada = tomadaPrevia !== undefined;
     const { raiz, manifesto } = carregado;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const fase = opcoes.fase;
@@ -566,12 +663,15 @@ function rodarFaseSobLock(carregado, threadId, opcoes) {
         gate: 'phase.dispatch', prompt, threadId: thread.id, modo: thread.modo, fase,
         bloco: thread.blocos.indexOf(blocoDespachado) + 1,
         blocoComGo: blocoDespachado.fases.includes('GO'),
-        temBaseline: (0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.baselineGravada),
+        // RM-037 (defeito 1): a baseline que o proprio despacho vai gravar conta como existente. O ensaio conta a
+        // que o despacho real gravaria (S2 do CHECK final), para nao mandar rodar a baseline que o CLI ja grava.
+        temBaseline: (0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.baselineGravada) ||
+            (opcoes.baselinePeloDespacho !== false && baselineDoDespachoNecessaria(carregado, thread.id, { ...opcoes, dryRun: false })),
         fallbackDoBloco: (0, setup_1.fallbackDoBloco)(setup, thread.modo, fase),
     });
     const bloqueiam = (0, policies_1.bloqueantes)(violacoes);
     // Warn registra e segue: o aviso vai ao ledger (fora do ensaio) e o despacho continua.
-    if (!opcoes.dryRun) {
+    if (!opcoes.dryRun && !segundaPassada) {
         for (const v of (0, policies_1.avisos)(violacoes)) {
             (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.politicaAviso, { gate: 'phase.dispatch', fase, slug,
                 policy: v.policy, detalhe: v.detalhe, correcao: v.correcao, modo: thread.modo });
@@ -633,7 +733,9 @@ function rodarFaseSobLock(carregado, threadId, opcoes) {
     }
     // I-36 (T7, T14): validado o pedido, a conducao da thread, antes de tocar a worktree. A mesma fase com o
     // mesmo prompt de quem conduz devolve a sessao em andamento sem chamar o adapter; outro pedido recebe a recusa.
-    const identidade = (0, runtime_context_1.novaIdentidadeDeDespacho)(thread.id, fase);
+    // Na repeticao, a identidade e a da tomada retida: a sessao reentra pela identidade gravada no lease (D4).
+    const identidade = tomadaPrevia ? { ...(0, runtime_context_1.novaIdentidadeDeDespacho)(thread.id, fase), dispatchId: tomadaPrevia.identidade }
+        : (0, runtime_context_1.novaIdentidadeDeDespacho)(thread.id, fase);
     const canal = opcoes.canal ?? (0, conducao_1.canalDoProcesso)();
     const pedidoDeConducao = { canal, correlacao: opcoes.correlacao ?? null, operacao: 'phase.run', fase,
         promptSha256: sha, identidade: identidade.dispatchId, prazoMs: prazoDaSessao(limites) };
@@ -654,12 +756,38 @@ function rodarFaseSobLock(carregado, threadId, opcoes) {
         return { ...base, sessionId: null, bloqueado: true, motivo: 'conducao.em-andamento', erro: recusa.texto, recusa,
             ...(atual ? { conducao: atual } : {}) };
     };
+    // RM-037 (defeito 3): o limite de sessoes do projeto vale no despacho, nao so no board. A recusa nao abre
+    // sessao nem toca a worktree; o `slot_refused` e a prova, fora da conta de atividade da thread.
+    const recusaPorVaga = (semVaga) => {
+        if (!opcoes.dryRun) {
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.vagaRecusada, { gate: 'phase.dispatch', motivo: 'concurrency.limite', fase, slug,
+                limite: semVaga.limite, ocupam: semVaga.ocupam, detalhe: semVaga.detalhe, correcao: semVaga.correcao,
+                evidencia: 'conducao exec:<thread> de sessao viva nas outras threads do projeto' });
+        }
+        return { thread, slug, promptPath, promptSha256: sha, comando: [], sessionId: null,
+            verificada: false, pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase), dryRun: opcoes.dryRun === true,
+            runtime, model, effort, bloqueado: true, motivo: 'concurrency.limite', violacoes, erro: `${semVaga.detalhe}; ${semVaga.correcao}`,
+            vaga: semVaga };
+    };
     let conducao = null;
     if (opcoes.dryRun) {
         // O ensaio nao toma nada, mas diz a verdade: com conducao em andamento, o despacho real seria recusado.
         const atual = (0, conducao_1.conducaoDaThread)(raiz, thread.id);
         if (atual)
             return ocupadaPor({ ok: false, idempotente: atual.fase === fase && atual.promptSha256 === sha, atual }, false);
+        const semVaga = (0, board_1.vagaDoDespacho)(carregado, thread.id);
+        if (semVaga)
+            return recusaPorVaga(semVaga);
+    }
+    else if (tomadaPrevia) {
+        // R5-B1 do CHECK 5: entre a sucessao da sessao blocked (1a passada) e aqui, a suite rodou com o lock HITL
+        // livre. Sob o lock de novo, o runtime confirma que a sucedida continua parada; se o dono a respondeu,
+        // ela recebe o lease de volta e este pedido espera a vez.
+        if (!tomadaPrevia.sucessaoAindaVale()) {
+            tomadaPrevia.devolver();
+            return ocupadaPor({ ok: false, idempotente: false, atual: (0, conducao_1.conducaoDaThread)(raiz, thread.id) }, true);
+        }
+        conducao = tomadaPrevia;
     }
     else {
         const tomada = (0, conducao_1.tomarConducao)(raiz, thread.id, pedidoDeConducao);
@@ -668,6 +796,29 @@ function rodarFaseSobLock(carregado, threadId, opcoes) {
         conducao = tomada;
     }
     try {
+        if (conducao) {
+            // A vaga e a baseline sao conferidas COM a conducao tomada (N2, N3 do CHECK 2): a tomada consulta o
+            // runtime, libera a orfa e faz a sucessao, e nenhum desses caminhos pode furar o limite nem soltar o
+            // codex sem baseline. Quem recusa antes da sessao DEVOLVE o que a tomada consumiu (A-1 do CHECK 3),
+            // pelo `finally`.
+            const semVaga = (0, board_1.vagaDoDespacho)(carregado, thread.id, undefined, (0, conducao_1.conducaoDaThread)(raiz, thread.id)?.desde);
+            if (semVaga)
+                return recusaPorVaga(semVaga);
+            if (baselineDoDespachoNecessaria(carregado, thread.id, opcoes)) {
+                const erro = `baseline.pendente: o bloco com GO no ${runtime} precisa da baseline antes do despacho` +
+                    (opcoes.baselinePeloDespacho === false ? ', e o MCP nao roda a suite' : ', e ela nao foi gravada') +
+                    `; rode ork verify ${thread.id} --baseline pelo CLI e repita o despacho`;
+                const pendente = { thread, slug, promptPath, promptSha256: sha, comando: [], sessionId: null,
+                    verificada: false, pausaAoFim: (0, thread_1.pausaNaThread)(thread, fase), dryRun: false,
+                    runtime, model, effort, bloqueado: true, motivo: 'baseline.pendente', violacoes, erro };
+                // Na primeira passada do CLI e do retry, a tomada fica retida para a baseline (o `finally` nao a solta).
+                if (opcoes.baselinePeloDespacho !== false && !segundaPassada) {
+                    pendente.retida = conducao;
+                    conducao = null;
+                }
+                return pendente;
+            }
+        }
         const cwd = thread.worktree ?? raiz;
         let contextoRuntime;
         try {
@@ -738,6 +889,7 @@ function rodarFaseSobLock(carregado, threadId, opcoes) {
             });
         }
         const pausaAoFim = (0, thread_1.pausaNaThread)(thread, fase);
+        const modoDaSessao = modoDaSessaoDoBloco(thread, fase);
         const claimsSchema = fase === 'GO' && runtime === 'codex'
             ? schemaDeClaimsDoPacote()
             : undefined;
@@ -755,12 +907,12 @@ function rodarFaseSobLock(carregado, threadId, opcoes) {
             vinculo: { thread: thread.id, fase, promptSha256: sha },
             contextoRuntime,
             ...(perfil ? { perfil } : {}),
-            ...(fase === 'PLAN' ? { colaboracao: 'plan' } : {}),
+            ...(modoDaSessao.plano ? { colaboracao: 'plan' } : {}),
             ...(claimsSchema ? { outputSchema: claimsSchema } : {}),
             // `thread.base.branch` vira a branch fonte quando a thread ganha worktree
             // (`ork/<slug>`). O review nativo precisa comparar essa fonte com a base de
             // integração do projeto; usar a própria fonte produz um diff vazio.
-            ...(fase === 'CHECK' && runtime === 'codex' ? { reviewBaseBranch: manifesto.worktree.base_branch } : {}),
+            ...(modoDaSessao.revisaoNativa && runtime === 'codex' ? { reviewBaseBranch: manifesto.worktree.base_branch } : {}),
             ...(limites ? { duracaoMaximaMs: limites.duracaoMs } : {}),
             // I-36 (D4): a sessao filha herda a identidade do despacho e o canal; e assim que ela reentra.
             ambienteExtra: (0, conducao_1.ambienteDaConducao)(identidade.dispatchId, thread.id, canal),
@@ -929,8 +1081,9 @@ function rodarFaseSobLock(carregado, threadId, opcoes) {
         };
     }
     finally {
-        // Despacho que nao virou sessao devolve a conducao; o que virou ja a entregou a sessao.
-        conducao?.liberar();
+        // Despacho que nao virou sessao devolve a conducao, com o que a tomada consumiu (reserva do canal, sessao
+        // blocked sucedida); o que virou ja a entregou a sessao, e devolver entao nao faz nada.
+        conducao?.devolver();
     }
 }
 /** Tabela de `ork phase list`: o historico do ledger da thread. */

package/dist/policies.js

@@ -38,6 +38,8 @@ const ENVS_QUE_REDIRECIONAM = [
  */
 const PADROES_DE_SEGREDO = [
     { nome: 'chave da Anthropic', regex: /sk-ant-[A-Za-z0-9_-]{16,}/ },
+    // I-38 (T7): chave do OpenRouter; o hifen depois de `sk-or-v1` escapa do padrao da OpenAI.
+    { nome: 'chave do OpenRouter', regex: /sk-or-v1-[A-Za-z0-9]{32,}/ },
     { nome: 'chave da OpenAI', regex: /\bsk-[A-Za-z0-9]{32,}\b/ },
     { nome: 'chave de acesso AWS', regex: /\bAKIA[0-9A-Z]{16}\b/ },
     { nome: 'token do GitHub', regex: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/ },