@orkastery/cli 0.2.0 → 0.4.1

package/dist/doctor.js

@@ -39,21 +39,72 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.checarContas = checarContas;
+exports.checarOnboarding = checarOnboarding;
 exports.checar = checar;
 exports.relatorio = relatorio;
 exports.doctor = doctor;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const adapter = __importStar(require("./adapters/claude-bg"));
+const codexAdapter = __importStar(require("./adapters/codex"));
 const manifest_1 = require("./manifest");
 const modos_1 = require("./modos");
 const orkmind_1 = require("./orkmind");
+const onboarding_1 = require("./onboarding");
 const ratelimit_1 = require("./ratelimit");
 const slug_1 = require("./slug");
+const horario_1 = require("./horario");
 const util_1 = require("./util");
+const sessoes_inventario_1 = require("./sessoes-inventario");
+const estado_thread_1 = require("./estado-thread");
+const project_state_1 = require("./project-state");
+const runtime_ambiente_1 = require("./runtime-ambiente");
+const runtime_profiles_1 = require("./runtime-profiles");
+const preflight_1 = require("./preflight");
+/**
+ * I-33 (D7): check "contas por runtime". Cada perfil ativo tem o login conferido pelo proprio
+ * CLI com o env dele (`claude auth status`, `codex login status`); o doctor so le e relata, sem
+ * marcar o store. Runtime com perfis e nenhum pronto reprova: o despacho dele nao sairia.
+ */
+function checarContas(raiz, auth = (p) => p.runtime === 'claude-bg' ? adapter.conferirAuth(p) : codexAdapter.conferirAuth(p)) {
+    let perfis;
+    try {
+        perfis = (0, runtime_profiles_1.lerPerfisComContas)(raiz).perfis.filter(p => p.estado !== 'desativado');
+    }
+    catch (e) {
+        return { nome: 'contas por runtime', nivel: 'fail', detalhe: `store de perfis invalido: ${e.message}`,
+            correcao: 'o store fica em .orkastery/private/runtime-profiles.json (arquivo 0600, pasta 0700)' };
+    }
+    if (perfis.length === 0)
+        return { nome: 'contas por runtime', nivel: 'ok',
+            detalhe: 'nenhum perfil configurado: cada runtime despacha pelo ambiente do processo' };
+    const partes = [];
+    let nivel = 'ok';
+    for (const runtime of runtime_profiles_1.RUNTIMES_COM_PERFIL) {
+        const doRuntime = perfis.filter(p => p.runtime === runtime);
+        if (doRuntime.length === 0)
+            continue;
+        const estados = doRuntime.map(p => {
+            const a = auth((0, runtime_profiles_1.perfilDeDespacho)(p));
+            return { id: p.id, pronto: a.ok && (0, runtime_profiles_1.perfilDisponivel)(p),
+                texto: !a.ok ? (a.pago ? 'provider pago (nunca despacha)' : a.transitorio ? 'conferencia de login inconclusiva' : 'sem login')
+                    : (0, runtime_profiles_1.perfilDisponivel)(p) ? 'pronto' : `${p.estado}${p.esgotadoAte ? ` ate ${p.esgotadoAte}` : ''}` };
+        });
+        const prontos = estados.filter(e => e.pronto).length;
+        if (prontos === 0)
+            nivel = 'fail';
+        else if (prontos < estados.length && nivel === 'ok')
+            nivel = 'warn';
+        partes.push(`${runtime}: ${estados.map(e => `${e.id} ${e.texto}`).join(', ')}`);
+    }
+    return { nome: 'contas por runtime', nivel, detalhe: partes.join('; '),
+        ...(nivel !== 'ok' ? { correcao: 'ork accounts check marca os perfis (sem-auth, provider-pago); ork accounts add refaz o login de assinatura pelo proprio CLI, nunca copiando credencial' } : {}) };
+}
 /**
  * Variaveis que REDIRECIONAM o despacho do `claude` para um provider pago.
- * Presenca delas com politica `subscription-only` e bloqueante (a licao dos US$ 16).
+ * Presenca delas com politica `subscription-only` e bloqueante: o despacho passaria a cobrar
+ * por token, fora da assinatura, sem ninguem pedir.
  */
 const ENVS_QUE_REDIRECIONAM = [
     'ANTHROPIC_API_KEY',
@@ -62,16 +113,36 @@ const ENVS_QUE_REDIRECIONAM = [
     'CLAUDE_CODE_USE_BEDROCK',
     'CLAUDE_CODE_USE_VERTEX',
 ];
-/**
- * Variaveis de provider pago que nao mudam o despacho do `claude`, mas indicam
- * credencial cobrada por token no ambiente. Viram aviso, nao bloqueio.
- */
-const ENVS_DE_PROVIDER_PAGO = ['OPENROUTER_API_KEY', 'OPENAI_API_KEY', 'GEMINI_API_KEY'];
 function versaoNode() {
     return Number(process.versions.node.split('.')[0]);
 }
+/** Checks locais; ler a entrevista não abre driver, banco, runtime ou rede. */
+function checarOnboarding(carregado) {
+    const estado = (0, onboarding_1.lerOnboarding)(carregado.raiz);
+    const pendentes = onboarding_1.ETAPAS_ONBOARDING.filter(e => estado.etapas[e] === null);
+    const checks = [{ nome: 'onboarding', nivel: pendentes.length ? 'warn' : 'ok',
+            detalhe: pendentes.length ? `${pendentes.length} etapa(s) pendente(s): ${pendentes.join(', ')}` : '9 etapas respondidas',
+            ...(pendentes.length ? { correcao: 'ork onboarding' } : {}) }];
+    const escolha = estado.etapas.memoria?.conteudo;
+    const modo = escolha === 'sim' || escolha === true ? 'orkmind' :
+        escolha === 'orkmind' || escolha === 'files' ? escolha :
+            escolha && typeof escolha === 'object' && !Array.isArray(escolha) ? escolha.modo : null;
+    if ((modo === 'orkmind' || modo === 'files') && modo !== carregado.manifesto.memory.mode) {
+        checks.push({ nome: 'onboarding memoria', nivel: 'warn', detalhe: `entrevista escolheu ${modo}; manifesto declara ${carregado.manifesto.memory.mode}`,
+            correcao: `revise memory.mode: ${modo} em orkastery.yaml; a entrevista não altera o manifesto` });
+    }
+    // I-35: o fuso respondido na etapa maestro orienta owner.timezone, sem editar o manifesto.
+    const maestro = estado.etapas.maestro?.conteudo;
+    const fusoDaEntrevista = maestro && typeof maestro === 'object' && !Array.isArray(maestro) ? (0, horario_1.normalizarFuso)(maestro.fuso) : undefined;
+    if (fusoDaEntrevista && fusoDaEntrevista !== carregado.manifesto.owner?.timezone) {
+        checks.push({ nome: 'onboarding fuso', nivel: 'warn',
+            detalhe: `entrevista informou ${fusoDaEntrevista}; manifesto declara ${carregado.manifesto.owner?.timezone ?? `${horario_1.CHAVE_DO_FUSO} ausente`}`,
+            correcao: `revise ${horario_1.CHAVE_DO_FUSO}: "${fusoDaEntrevista}" em orkastery.yaml; a entrevista não altera o manifesto` });
+    }
+    return checks;
+}
 /** Roda todos os checks a partir do diretorio informado. */
-function checar(dirInicial = process.cwd()) {
+function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)()) {
     const checks = [];
     const major = versaoNode();
     checks.push({
@@ -104,6 +175,37 @@ function checar(dirInicial = process.cwd()) {
         detalhe: claude ? `${claude} (${v ?? 'versao desconhecida'})` : 'binario `claude` fora do PATH',
         correcao: claude ? undefined : 'instale o Claude Code e garanta `claude` no PATH',
     });
+    // Segundo runtime homologado. Ausente e `warn`, nao `fail`: o claude-bg segue sendo o
+    // padrao, e um projeto que nunca pediu codex nao pode ficar bloqueado por ele.
+    const codex = codexAdapter.disponivel();
+    const codexVersao = codex ? codexAdapter.versao() : null;
+    checks.push({
+        nome: 'runtime codex',
+        nivel: codex ? 'ok' : 'warn',
+        detalhe: codex
+            ? `${codex} (${codexVersao ?? 'versao desconhecida'})`
+            : 'binario `codex` fora do PATH (opcional: claude-bg e o runtime padrao)',
+        correcao: codex
+            ? undefined
+            : 'para despachar pelo codex, instale o Codex CLI e autentique com `codex login`',
+    });
+    // Pitfall MEDIDO em 06/09/2026: com o sandbox quebrado, o `codex exec` sai 0 e o agente
+    // NARRA sucesso sem executar nada. A sonda e deterministica (roda `true`, sem LLM).
+    let sondaDoCodex = null;
+    if (codex) {
+        sondaDoCodex = codexAdapter.sondarSandbox();
+        checks.push({
+            nome: 'sandbox do codex',
+            nivel: sondaDoCodex.ok ? 'ok' : 'warn',
+            detalhe: sondaDoCodex.ok
+                ? '`codex sandbox true` executa nesta maquina'
+                : `sonda \`codex sandbox true\` falhou: ${sondaDoCodex.detalhe}`,
+            correcao: sondaDoCodex.ok
+                ? undefined
+                : 'instale o pacote bubblewrap do sistema (o bwrap embutido nao cria user namespace ' +
+                    'nesta maquina) ou declare runtime.sandbox: danger-full-access ciente do risco',
+        });
+    }
     const carregado = (0, manifest_1.carregarManifesto)(dirInicial);
     if (!carregado) {
         checks.push({
@@ -123,6 +225,7 @@ function checar(dirInicial = process.cwd()) {
                     (carregado.avisos.length > 0 ? `; ${carregado.avisos.join('; ')}` : ''),
             correcao: carregado.erros.length > 0 ? 'corrija o manifesto e rode ork doctor de novo' : undefined,
         });
+        checks.push(...checarOnboarding(carregado));
         const abbrev = carregado.manifesto.project.abbrev;
         const checkAbbrev = (0, slug_1.validarAbbrev)(abbrev);
         checks.push({
@@ -140,13 +243,43 @@ function checar(dirInicial = process.cwd()) {
             detalhe: `padrao ${modos_1.MODOS[cond.default_mode].tag}; ` +
                 `permitidos ${cond.allowed_modes.map((m) => modos_1.MODOS[m].tag).join(', ')}`,
         });
+        // I-35: o fuso em que todo horario chega ao dono; valor invalido avisa e nao para nada.
+        const fuso = (0, horario_1.fusoDoManifesto)(carregado);
+        checks.push({
+            nome: 'fuso do dono',
+            nivel: fuso.aviso ? 'warn' : 'ok',
+            detalhe: fuso.aviso ?? (fuso.origem === 'manifesto'
+                ? `${fuso.fuso} (${horario_1.CHAVE_DO_FUSO}); horarios para pessoas em ${(0, horario_1.rotuloDoFuso)(fuso.fuso)}`
+                : `${fuso.fuso} (fuso do sistema; ${horario_1.CHAVE_DO_FUSO} nao configurado)`),
+            correcao: fuso.aviso ? `corrija ${horario_1.CHAVE_DO_FUSO} com um nome IANA` : undefined,
+        });
+        // Quando o manifesto ELEGE o codex como runtime de despacho, a ausencia dele (ou um
+        // sandbox que nao executa) deixa de ser aviso: e exatamente o que bloquearia a fase.
+        if (carregado.manifesto.runtime.adapter === 'codex') {
+            const sandboxConfigurado = carregado.manifesto.runtime.sandbox;
+            const sandboxQuebrado = sondaDoCodex !== null && !sondaDoCodex.ok && sandboxConfigurado !== 'danger-full-access';
+            checks.push({
+                nome: 'despacho pelo codex',
+                nivel: !codex ? 'fail' : sandboxQuebrado ? 'fail' : 'ok',
+                detalhe: !codex
+                    ? 'runtime.adapter: codex, mas o binario `codex` esta fora do PATH'
+                    : sandboxQuebrado
+                        ? `runtime.adapter: codex com sandbox "${sandboxConfigurado}", mas o sandbox nao executa nesta maquina (o agente narraria sucesso sem rodar nada)`
+                        : `runtime.adapter: codex com sandbox "${sandboxConfigurado}"`,
+                correcao: !codex
+                    ? 'instale o Codex CLI e autentique com `codex login` (assinatura, nunca API key)'
+                    : sandboxQuebrado
+                        ? 'instale o bubblewrap do sistema, ou declare runtime.sandbox: danger-full-access ciente do risco'
+                        : undefined,
+            });
+        }
         const politica = carregado.manifesto.runtime.provider_policy;
         const soAssinatura = politica === 'subscription-only';
-        const redirecionam = ENVS_QUE_REDIRECIONAM.filter((e) => (process.env[e] ?? '').trim() !== '');
-        const pagas = ENVS_DE_PROVIDER_PAGO.filter((e) => (process.env[e] ?? '').trim() !== '');
+        const redirecionam = ENVS_QUE_REDIRECIONAM.filter(e => nomesHerdados.includes(e));
+        const pagas = nomesHerdados;
         const bloqueia = soAssinatura && redirecionam.length > 0;
         checks.push({
-            nome: 'custo e provider',
+            nome: 'custo e provider herdado',
             nivel: bloqueia ? 'fail' : soAssinatura && pagas.length > 0 ? 'warn' : 'ok',
             detalhe: bloqueia
                 ? `politica ${politica} violada: ${redirecionam.join(', ')} redireciona o despacho do claude`
@@ -159,10 +292,19 @@ function checar(dirInicial = process.cwd()) {
                     ? `nenhuma acao obrigatoria; nunca despache fase por ${pagas.join(', ')}`
                     : undefined,
         });
+        const efetivas = (0, runtime_ambiente_1.nomesDeProviderAtivos)();
+        checks.push({
+            nome: 'provider efetivo da fabrica',
+            nivel: soAssinatura && efetivas.length ? 'warn' : 'ok',
+            detalhe: efetivas.length ? `nomes ativos: ${efetivas.join(', ')}` : 'nenhum nome da lista de provider ativo',
+        });
         // Bloco B6: o regime de memoria e um CHECK, nao um detalhe do manifesto. Manifesto
         // que pede `orkmind` e nao consegue liga-lo vira `warn` com a correcao, nunca `fail`:
         // memoria semantica melhora o produto, e nao e requisito dele.
-        const { estado } = (0, orkmind_1.resolverRegime)(carregado.manifesto, null);
+        const context = (0, project_state_1.memoryState)(carregado);
+        const { estado } = (0, orkmind_1.resolverRegime)(context.loaded.manifesto, null);
+        checks.push({ nome: 'fonte da memoria', nivel: context.divergent ? 'warn' : 'ok',
+            detalhe: `${context.source}${context.divergent ? ' (cópia da worktree divergente preservada)' : ''}` });
         checks.push({
             nome: 'regime de memoria',
             nivel: estado.efetivo === 'orkmind' ? 'ok' : estado.pedido === 'orkmind' ? 'warn' : 'ok',
@@ -185,14 +327,14 @@ function checar(dirInicial = process.cwd()) {
             detalhe: fila.length === 0
                 ? 'vazia: nenhuma fase morreu por limite de uso neste projeto'
                 : `${esperando.length} aguardando janela, ${escalados.length} escalado(s) para humano` +
-                    (esperando.length > 0 ? `; proxima janela em ${esperando[0].liberaEm}` : ''),
+                    (esperando.length > 0 ? `; proxima janela em ${(0, horario_1.formatarDataHoraRotulada)(esperando[0].liberaEm)}` : ''),
             correcao: escalados.length > 0
-                ? `pedido escalado alem do limite de retry.max_tentativas: ork retry list e ork gate approve`
+                ? `pedido escalado alem do limite de retry.max_tentativas: ork retry list e ork gate request <thread>`
                 : esperando.length > 0
                     ? 'ork retry resume retoma o que ja liberou'
                     : undefined,
         });
-        const dirEstadoProjeto = path.join(carregado.raiz, manifest_1.DIR_ESTADO);
+        const dirEstadoProjeto = path.join((0, estado_thread_1.raizDoEstado)(carregado.raiz), manifest_1.DIR_ESTADO);
         const threads = path.join(dirEstadoProjeto, 'threads');
         const qtd = fs.existsSync(threads)
             ? fs.readdirSync(threads, { withFileTypes: true }).filter((e) => e.isDirectory()).length
@@ -205,14 +347,19 @@ function checar(dirInicial = process.cwd()) {
                 : `${dirEstadoProjeto} ausente`,
             correcao: fs.existsSync(dirEstadoProjeto) ? undefined : 'ork init cria o diretorio de estado',
         });
-        if (claude) {
-            const sessoes = adapter.listarSessoes(carregado.raiz);
+        checks.push(checarContas(carregado.raiz));
+        // I-33 (D7): umask e permissoes do estado, na mesma regra do sensor (sem bits 0o022).
+        checks.push(...(0, preflight_1.sondasDeAmbiente)(carregado.raiz));
+        {
+            const inventario = (0, sessoes_inventario_1.inventariarSessoes)(carregado.raiz, { global: true, todas: true });
             checks.push({
-                nome: 'sessoes vivas do projeto',
-                nivel: 'ok',
-                detalhe: sessoes.length === 0
-                    ? 'nenhuma sessao ativa sob a raiz do projeto'
-                    : sessoes.map((s) => `${s.name ?? s.sessionId.slice(0, 8)} (${s.state ?? s.status ?? '?'})`).join(', '),
+                nome: 'governanca de sessoes',
+                nivel: inventario.ok && inventario.semThread === 0 ? 'ok' : 'warn',
+                detalhe: `${inventario.escopo.usuario}, Claude e Codex, global com histórico: ${inventario.total} sessões; ` +
+                    `${inventario.semThread} sem thread; ${inventario.ambiguas} ambíguas; ` +
+                    `inventário ${inventario.ok ? 'válido' : 'INCOMPLETO (zero não comprovado)'}`,
+                correcao: inventario.ok && inventario.semThread === 0 ? undefined :
+                    'ork sessions --global --all --json; adote identidades sem vínculo com ork sessions adopt <id>',
             });
         }
     }
@@ -224,12 +371,24 @@ function relatorio(checks) {
     linhas.push('ork doctor: o que vale nesta maquina agora');
     linhas.push('');
     const largura = Math.max(...checks.map((c) => c.nome.length));
+    // I-35: o Check guarda o ISO (dado de maquina, tambem lido por teste); quem imprime para o dono
+    // localiza. Vale para todo check, nao so o de contas: nenhum horario chega cru ao relatorio.
+    let localizou = false;
+    const local = (t) => {
+        const l = (0, horario_1.localizarTexto)(t);
+        if (l !== t)
+            localizou = true;
+        return l;
+    };
     for (const c of checks) {
-        linhas.push(`  ${(0, util_1.simbolo)(c.nivel)} ${c.nome.padEnd(largura)}  ${c.detalhe}`);
+        linhas.push(`  ${(0, util_1.simbolo)(c.nivel)} ${c.nome.padEnd(largura)}  ${local(c.detalhe)}`);
         if (c.nivel !== 'ok' && c.correcao) {
-            linhas.push(`         ${' '.repeat(largura)}  correcao: ${c.correcao}`);
+            linhas.push(`         ${' '.repeat(largura)}  correcao: ${local(c.correcao)}`);
         }
     }
+    // O fuso sai uma vez por mensagem, antes do veredito, que segue sendo a ultima linha.
+    if (localizou && !linhas.some((l) => l.includes((0, horario_1.legendaDoFuso)())))
+        linhas.push((0, horario_1.legendaDoFuso)());
     const falhas = checks.filter((c) => c.nivel === 'fail').length;
     const avisos = checks.filter((c) => c.nivel === 'warn').length;
     linhas.push('');
@@ -239,8 +398,8 @@ function relatorio(checks) {
     return linhas.join('\n');
 }
 /** Executa o doctor e devolve o codigo de saida (0 = pronto). */
-function doctor(dirInicial = process.cwd()) {
-    const checks = checar(dirInicial);
+function doctor(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)()) {
+    const checks = checar(dirInicial, nomesHerdados);
     const falhas = checks.filter((c) => c.nivel === 'fail').length;
     return { texto: relatorio(checks), codigo: falhas > 0 ? 1 : 0 };
 }

package/dist/entrega-pr.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeDaEntrega = mergeDaEntrega;
+exports.registrarEntregaPorPr = registrarEntregaPorPr;
+exports.registrarEntregasPorPr = registrarEntregasPorPr;
+/**
+ * I-57 (RM-008, fatia 2): a entrega feita por PR tambem prova entrega para o MASTER.
+ *
+ * O fluxo de entrega desta fabrica e o PR: CI independente verde no SHA exato, merge com
+ * `--match-head-commit` e o assunto `ship(<thread>): ...`. So que o MASTER exigia o `ship_done`
+ * do `ork ship`, e a thread entregue por PR ficava aberta para sempre: nao fechava, nao virava
+ * licao para o loop de aprendizado, e o board a mostrava como trabalho em curso.
+ *
+ * Aqui a mesma prova vira `ship_done`, com o que a sustenta de verdade: o merge dentro da base
+ * remota (ancestralidade conferida contra a ponta que o `ls-remote` devolve) e o check do CI no
+ * head do PR. Sem CI verde, nao registra: merge sem prova independente nao e entrega.
+ */
+const ci_1 = require("./ci");
+const fabrica_publicar_1 = require("./fabrica-publicar");
+const ledger_1 = require("./ledger");
+const modos_1 = require("./modos");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+/** O merge `ship(<thread>)` mais recente na base remota, com o head do PR (segundo pai). */
+function mergeDaEntrega(raiz, thread, remoto, base) {
+    const r = (0, util_1.exec)('git', ['log', `refs/remotes/${remoto}/${base}`, '--first-parent', '--format=%H%x09%P%x09%s', `--grep=^ship(${thread})`], raiz);
+    if (!r.ok)
+        return null;
+    for (const linha of r.stdout.split('\n')) {
+        const [sha, pais, assunto] = linha.split('\t');
+        if (!sha || !assunto || !assunto.startsWith(`ship(${thread})`))
+            continue;
+        const segundo = (pais ?? '').split(' ')[1] ?? null;
+        return { mergeSha: sha, headSha: segundo };
+    }
+    return null;
+}
+function resultado(thread, acao, motivo, extra = {}) {
+    return { thread, acao, motivo, mergeSha: null, headSha: null, ci: null, ...extra };
+}
+/**
+ * `ork ship registrar-pr <thread>`: grava o `ship_done` da entrega feita por PR. Idempotente:
+ * a mesma entrega nao e registrada duas vezes.
+ */
+function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
+    const raiz = carregado.raiz;
+    const remoto = opcoes.remoto ?? 'origin';
+    const base = carregado.manifesto.worktree.base_branch;
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    if (thread.status === 'fechada')
+        return resultado(threadId, 'ja-registrada', 'thread ja fechada');
+    if (opcoes.buscar !== false)
+        (0, util_1.exec)('git', ['fetch', '-q', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], raiz);
+    const merge = mergeDaEntrega(raiz, threadId, remoto, base);
+    if (!merge)
+        return resultado(threadId, 'sem-merge', `nenhum merge ship(${threadId}) em ${remoto}/${base}`);
+    const dir = (0, thread_1.dirThread)(raiz, threadId);
+    const jaTem = (0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && e.mergeSha === merge.mergeSha);
+    if (jaTem)
+        return resultado(threadId, 'ja-registrada', 'esta entrega ja tem ship_done', merge);
+    // A ponta do remoto AGORA, e o merge dentro dela: e o que torna o push provado, nao presumido.
+    const remotoAgora = (0, util_1.exec)('git', ['ls-remote', remoto, `refs/heads/${base}`], raiz);
+    const ponta = remotoAgora.ok ? remotoAgora.stdout.split('\t')[0].trim() : '';
+    if (!ponta || !(0, util_1.exec)('git', ['merge-base', '--is-ancestor', merge.mergeSha, ponta], raiz).ok) {
+        return resultado(threadId, 'recusada', `o merge ${merge.mergeSha.slice(0, 7)} nao esta na ponta de ${remoto}/${base}`, merge);
+    }
+    const ci = (0, ci_1.consultarCi)(carregado, merge.headSha ?? merge.mergeSha, remoto, opcoes.executorCi);
+    if (ci.required && !ci.ok) {
+        return resultado(threadId, 'recusada', `sem CI verde no head do PR: ${ci.detail}`, { ...merge, ci });
+    }
+    (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipConcluido, {
+        de: thread.base?.branch ?? null,
+        para: base,
+        shaDe: merge.headSha,
+        mergeSha: merge.mergeSha,
+        jaIncorporado: true,
+        remoto,
+        shaRemoto: ponta,
+        pushVerificado: true,
+        fonteDaProva: `git merge-base --is-ancestor ${merge.mergeSha} ${ponta} (ls-remote ${remoto} refs/heads/${base})`,
+        autorizadoPor: 'merge de PR com o CI independente verde no SHA exato',
+        tipoDeAutorizacao: 'pr',
+        modo: thread.modo,
+        tag: (0, modos_1.tagDoModo)(thread.modo),
+        evidencia: { viaPr: true, ci: { state: ci.state, context: ci.context, url: ci.url, sha: ci.sha } },
+    });
+    // Como no `ork ship`: a thread chega ao SHIP quando o ciclo dela tem SHIP.
+    const atualizada = (0, thread_1.lerThread)(raiz, threadId);
+    if (atualizada.fases?.includes('SHIP')) {
+        atualizada.faseAtual = 'SHIP';
+        (0, thread_1.gravarThread)(raiz, atualizada);
+    }
+    if (opcoes.publicar !== false)
+        (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
+    return resultado(threadId, 'registrou', `ship_done pelo merge ${merge.mergeSha.slice(0, 7)} do PR`, { ...merge, ci });
+}
+/** `ork ship registrar-pr --todas`: toda thread aberta que ja tem merge `ship(<thread>)` na base. */
+function registrarEntregasPorPr(carregado, opcoes = {}) {
+    const remoto = opcoes.remoto ?? 'origin';
+    const base = carregado.manifesto.worktree.base_branch;
+    (0, util_1.exec)('git', ['fetch', '-q', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], carregado.raiz);
+    const r = (0, thread_1.listarIds)(carregado.raiz)
+        .filter((id) => (0, thread_1.lerThread)(carregado.raiz, id).status !== 'fechada')
+        .filter((id) => mergeDaEntrega(carregado.raiz, id, remoto, base) !== null)
+        .map((id) => {
+        try {
+            return registrarEntregaPorPr(carregado, id, { ...opcoes, buscar: false, publicar: false });
+        }
+        catch (e) {
+            return resultado(id, 'recusada', e.message);
+        }
+    });
+    // Uma publicacao so para o lote inteiro, nao uma por thread.
+    if (r.some((x) => x.acao === 'registrou'))
+        (0, fabrica_publicar_1.publicarEmSegundoPlano)(carregado.raiz);
+    return r;
+}

package/dist/escopo-escrita.js

@@ -0,0 +1,71 @@
+"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.THREADS_PROTEGIDAS = void 0;
+exports.validarThreadDeEscrita = validarThreadDeEscrita;
+exports.exigirEscopoDeEscrita = exigirEscopoDeEscrita;
+exports.validarDiretorioDeThread = validarDiretorioDeThread;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+/** Autorizar leitura de um tenant nao autoriza escrever em suas threads. */
+exports.THREADS_PROTEGIDAS = new Set([
+    'ork-grandeevoluc', 'ork-jornadasdpa', 'ork-renarrativac',
+]);
+function validarThreadDeEscrita(id) {
+    if (typeof id !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(id)) {
+        throw new Error('scope.thread.invalid');
+    }
+    if (exports.THREADS_PROTEGIDAS.has(id.toLowerCase()))
+        throw new Error('scope.thread.protected');
+}
+function exigirEscopoDeEscrita(threads) {
+    if (!Array.isArray(threads) || threads.length === 0)
+        throw new Error('scope.write.required');
+    threads.forEach(validarThreadDeEscrita);
+    return new Set(threads);
+}
+/** Um nome autorizado nao pode ser alias de outra thread ou de estado externo. */
+function validarDiretorioDeThread(raiz, id) {
+    validarThreadDeEscrita(id);
+    const dir = (0, estado_thread_1.estadoCanonico)(raiz, id);
+    for (const candidato of [path.dirname(path.dirname(dir)), path.dirname(dir), dir]) {
+        const stat = fs.lstatSync(candidato, { throwIfNoEntry: false });
+        if (!stat)
+            throw new Error('scope.thread.missing');
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            throw new Error('scope.thread.alias');
+    }
+}