@orkastery/cli 0.4.2 → 0.5.0

package/dist/decisao-autonoma.js

@@ -39,7 +39,43 @@ const hitl_gates_1 = require("./hitl-gates");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
 const modos_1 = require("./modos");
+const conducao_1 = require("./conducao");
 exports.CONTRATO_DECISAO_AUTONOMA = 'ork.decisao-autonoma/v1';
+/**
+ * A sessao de OUTRA thread que registra aqui tambem deixa rastro (S-3 do CHECK 3). So o par que o ledger
+ * daquela thread confirma (S-b do CHECK 4): o par vazado do daemon do `claude --bg` nao vira rastro falso.
+ */
+function despachoDeOutraThread(raiz, threadId) {
+    const thread = (process.env[conducao_1.ENV_THREAD_DO_DESPACHO] ?? '').trim(), id = (process.env[conducao_1.ENV_IDENTIDADE_DE_DESPACHO] ?? '').trim();
+    if (!thread || thread === threadId || !/^[a-z0-9]{1,3}-[a-z0-9]{1,12}$/.test(thread) || !/^[a-f0-9-]{36}$/.test(id))
+        return {};
+    // R5-A2 do CHECK 5: a mesma conferencia D-4 da reentrada. O par que o daemon do `claude --bg` vazou e um
+    // despacho real, que o ledger confirma; so a sessao que o recebeu de fato o valida.
+    let confirmado = false;
+    try {
+        confirmado = (0, conducao_1.identidadeDoAmbiente)(thread, process.env, raiz) === id;
+    }
+    catch { /* thread de outro projeto ou ilegivel: sem prova, sem rastro */ }
+    if (confirmado) {
+        try {
+            confirmado = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread)).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada &&
+                e.identidade?.dispatchId === id);
+        }
+        catch {
+            confirmado = false;
+        }
+    }
+    return confirmado ? { despachoNoAmbiente: { thread, dispatchId: id } } : {};
+}
+/** O canal do processo; canal fora do registro nao impede a decisao, e fica dito como tal. */
+function canalSeguro() {
+    try {
+        return (0, conducao_1.canalDoProcesso)();
+    }
+    catch {
+        return 'desconhecido';
+    }
+}
 /** D3/M7: o p90 das 155 fases ja medidas. Acima disso a fase esta no decil mais alto do projeto. */
 exports.LIMIAR_DE_DECISOES_POR_FASE = 13;
 /** Os nomes que o rastro teve antes de ser tipado (M6), na ordem em que valem na leitura. */
@@ -110,6 +146,12 @@ function registrarDecisao(raiz, threadId, entrada) {
         const evento = (0, ledger_1.registrar)(dir, t.id, ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma, {
             contratoDecisao: exports.CONTRATO_DECISAO_AUTONOMA, fase: pedido.fase, decisao: pedido.decidido, ...rastro,
             pedido, ...(entrada.reverte ? { reverte: entrada.reverte } : {}),
+            origem: entrada.origem ?? 'cli', ...(entrada.host ? { host: entrada.host } : {}),
+            // RM-037 (S5 do CHECK): a porta e quem chamou, pelo processo e nao pelo texto de `quemDecidiu`. A sessao
+            // despachada carrega a identidade do despacho no ambiente; o dono no terminal, nao.
+            canal: entrada.origem === 'mcp' && entrada.host ? entrada.host : canalSeguro(),
+            despacho: entrada.despacho !== undefined ? entrada.despacho : (0, conducao_1.identidadeDoAmbiente)(t.id, process.env, raiz),
+            ...despachoDeOutraThread(raiz, t.id),
         });
         return { pedido, evento };
     });

package/dist/docs.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIMITE_DO_PARAGRAFO = exports.LIMITE_DA_FRASE = exports.CATEGORIAS = exports.DIMENSOES = exports.ESTADOS_DA_ESPECIFICACAO = exports.DIR_PADROES = exports.DIR_ROADMAP = exports.DIR_PRODUTO = void 0;
 exports.separarFrontmatter = separarFrontmatter;
+exports.ehPaginaDeDocs = ehPaginaDeDocs;
+exports.documentoDeTexto = documentoDeTexto;
 exports.carregarDocs = carregarDocs;
 exports.resolverBase = resolverBase;
 exports.comandosDaAjuda = comandosDaAjuda;
@@ -44,6 +46,7 @@ exports.renderizarEstado = renderizarEstado;
 exports.textoDaVerificacao = textoDaVerificacao;
 exports.escreverYaml = escreverYaml;
 exports.mergeDaThread = mergeDaThread;
+exports.escopoPadraoDoSync = escopoPadraoDoSync;
 exports.sincronizarDocs = sincronizarDocs;
 exports.tabelaDoRoadmap = tabelaDoRoadmap;
 exports.tabelaDoProduto = tabelaDoProduto;
@@ -136,38 +139,49 @@ function separarFrontmatter(texto) {
         return { bruto: null, corpo: t };
     return { bruto: t.slice(4, fim + 1), corpo: t.slice(fim + 5) };
 }
+/** `_modelo-*.md` e `README.md` sao modelo e indice, nao paginas de entidade. */
+function ehPaginaDeDocs(nome) {
+    return nome.endsWith('.md') && !nome.startsWith('_') && nome !== 'README.md';
+}
 function paginas(raiz, dir) {
     const abs = path.join(raiz, dir);
     if (!fs.existsSync(abs))
         return [];
-    // `_modelo-*.md` e `README.md` sao modelo e indice, nao paginas de entidade.
     return fs.readdirSync(abs)
-        .filter((n) => n.endsWith('.md') && !n.startsWith('_') && n !== 'README.md')
+        .filter(ehPaginaDeDocs)
         .sort()
         .map((n) => `${dir}/${n}`);
 }
+/**
+ * RM-054: uma pagina a partir do texto, venha ele do disco, de um blob do git ou da forja. O
+ * achado e o mesmo que a leitura do disco daria.
+ */
+function documentoDeTexto(arquivo, texto) {
+    const { bruto, corpo } = separarFrontmatter(texto);
+    if (bruto === null) {
+        return { achado: erro(arquivo, undefined, 'docs.frontmatter.ausente', 'página sem frontmatter YAML', 'comece o arquivo com as chaves do modelo entre duas linhas ---') };
+    }
+    let dados;
+    try {
+        dados = (0, yaml_1.lerYaml)(bruto);
+    }
+    catch (e) {
+        return { achado: erro(arquivo, undefined, 'docs.frontmatter.invalido', `frontmatter inválido: ${e.message}`) };
+    }
+    if (!ehMapa(dados)) {
+        return { achado: erro(arquivo, undefined, 'docs.frontmatter.invalido', 'o frontmatter precisa ser um mapa de chaves') };
+    }
+    return { doc: { arquivo, tipo: dados.tipo, id: String(dados.id ?? ''), dados, corpo } };
+}
 function carregarDocs(raiz) {
     const docs = [];
     const achados = [];
     for (const arquivo of [...paginas(raiz, exports.DIR_PRODUTO), ...paginas(raiz, exports.DIR_ROADMAP)]) {
-        const { bruto, corpo } = separarFrontmatter(fs.readFileSync(path.join(raiz, arquivo), 'utf8'));
-        if (bruto === null) {
-            achados.push(erro(arquivo, undefined, 'docs.frontmatter.ausente', 'página sem frontmatter YAML', 'comece o arquivo com as chaves do modelo entre duas linhas ---'));
-            continue;
-        }
-        let dados;
-        try {
-            dados = (0, yaml_1.lerYaml)(bruto);
-        }
-        catch (e) {
-            achados.push(erro(arquivo, undefined, 'docs.frontmatter.invalido', `frontmatter inválido: ${e.message}`));
-            continue;
-        }
-        if (!ehMapa(dados)) {
-            achados.push(erro(arquivo, undefined, 'docs.frontmatter.invalido', 'o frontmatter precisa ser um mapa de chaves'));
-            continue;
-        }
-        docs.push({ arquivo, tipo: dados.tipo, id: String(dados.id ?? ''), dados, corpo });
+        const lido = documentoDeTexto(arquivo, fs.readFileSync(path.join(raiz, arquivo), 'utf8'));
+        if ('doc' in lido)
+            docs.push(lido.doc);
+        else
+            achados.push(lido.achado);
     }
     return { docs, achados };
 }
@@ -664,12 +678,40 @@ function temBranch(raiz, thread) {
     return r.ok && r.saida.length > 0;
 }
 const ORDEM_DO_CODIGO = exports.DIMENSOES.codigo;
+/**
+ * RM-037 (rm037noite, defeito 5): o escopo padrao do `ork docs sincronizar`. Na worktree de uma thread
+ * com item do roadmap, so o item dela: da worktree da ork-rm037noite, o sincronizar gravava RM-025,
+ * 026, 031, 038, 048, 049, 050 e 054, e cada PR conflitava com as outras. Fora de worktree de thread
+ * (a raiz, onde o condutor sincroniza depois do merge), todo item, como antes.
+ */
+function escopoPadraoDoSync(raiz) {
+    const real = (p) => { try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return path.resolve(p);
+    } };
+    const aqui = real(raiz);
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        let t;
+        try {
+            t = (0, thread_1.lerThread)(raiz, id);
+        }
+        catch {
+            continue;
+        }
+        if (t.worktree && real(t.worktree) === aqui)
+            return { itens: t.roadmap ? [t.roadmap] : null, thread: t.id };
+    }
+    return { itens: null, thread: null };
+}
 function sincronizarDocs(raiz, opcoes = {}) {
     const base = resolverBase(raiz, opcoes.baseBranch) ?? (opcoes.baseBranch ?? 'main');
     const agora = opcoes.agora ?? (() => isoComFusoLocal(new Date()));
     const { docs } = carregarDocs(raiz);
     const mudancas = [];
-    for (const d of docs.filter((x) => x.tipo === 'roadmap')) {
+    const noEscopo = (d) => !opcoes.itens || opcoes.itens.includes(d.id);
+    for (const d of docs.filter((x) => x.tipo === 'roadmap' && noEscopo(x))) {
         const sdlc = ehMapa(d.dados.sdlc) ? d.dados.sdlc : null;
         const thread = sdlc && typeof sdlc.thread === 'string' ? sdlc.thread : null;
         if (!thread)
@@ -715,7 +757,7 @@ function sincronizarDocs(raiz, opcoes = {}) {
     }
     // As tabelas de estado do corpo sao vistas do frontmatter: regeradas em todo item de roadmap,
     // inclusive quando a pessoa mudou o frontmatter a mao (ciclo, deploy, exposicao...).
-    for (const d of docs.filter((x) => x.tipo === 'roadmap')) {
+    for (const d of docs.filter((x) => x.tipo === 'roadmap' && noEscopo(x))) {
         const novo = substituirBloco(substituirBloco(d.corpo, RELANCE_INI, RELANCE_FIM, renderizarRelance(d)), ESTADO_INI, ESTADO_FIM, renderizarEstado(d));
         if (novo !== d.corpo) {
             if (!mudancas.some((m) => m.id === d.id)) {

package/dist/doctor.js

@@ -40,6 +40,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checarContas = checarContas;
+exports.checarChaveDeEmbedding = checarChaveDeEmbedding;
 exports.checarOnboarding = checarOnboarding;
 exports.checar = checar;
 exports.relatorio = relatorio;
@@ -116,6 +117,37 @@ const ENVS_QUE_REDIRECIONAM = [
 function versaoNode() {
     return Number(process.versions.node.split('.')[0]);
 }
+/**
+ * I-38 (T7): a chave de embedding aparece pelo NOME, nunca pelo valor. Ausente e aviso (a busca
+ * cai para o fallback local ou para FTS e o regime segue); nome de provider pago e falha, porque a
+ * entrada do `ork` apagaria a variavel sob `subscription-only` e o preflight reprovaria o codex.
+ */
+function checarChaveDeEmbedding(carregado, env = process.env) {
+    const nome = 'chave de embedding';
+    const config = (0, manifest_1.configDeEmbedding)(carregado.manifesto);
+    if (config.provider === 'none')
+        return { nome, nivel: 'ok', detalhe: 'memory.embedding com provider none: busca por significado desligada' };
+    const variavel = config.api_key_env;
+    if (runtime_ambiente_1.ENVS_DE_PROVIDER_PAGO.includes(variavel)) {
+        return { nome, nivel: 'fail', detalhe: `memory.embedding.api_key_env declara ${variavel}, nome da lista de provider pago`,
+            correcao: 'use uma chave dedicada ao Orkastery com nome proprio, por exemplo ORKASTERY_EMBEDDING_API_KEY' };
+    }
+    if (!variavel) {
+        return { nome, nivel: 'fail', detalhe: `memory.embedding com provider ${config.provider} sem api_key_env`,
+            correcao: 'declare em memory.embedding.api_key_env o NOME da variavel com a chave dedicada' };
+    }
+    const valor = (env[variavel] ?? '').trim();
+    const dsn = carregado.manifesto.memory.database_url_env ? (env[carregado.manifesto.memory.database_url_env] ?? '') : '';
+    if (valor !== '' && !(0, orkmind_1.chaveDeEmbeddingAceita)(valor, dsn)) {
+        return { nome, nivel: 'fail', detalhe: `${variavel} tem valor recusado: parece URL, DSN ou texto com espaco (valor nunca impresso)`,
+            correcao: `confira se ${variavel} guarda a chave dedicada, e nao outra credencial` };
+    }
+    if (valor !== '') {
+        return { nome, nivel: 'ok', detalhe: `${variavel} presente no ambiente (valor nunca impresso); ${config.provider} ${config.model}` };
+    }
+    return { nome, nivel: 'warn', detalhe: `${variavel} ausente do ambiente: a busca por significado usa o fallback local ou cai para FTS; o regime nao muda`,
+        correcao: `exporte ${variavel} com a chave dedicada ao Orkastery (com limite de credito no painel do provider)` };
+}
 /** Checks locais; ler a entrevista não abre driver, banco, runtime ou rede. */
 function checarOnboarding(carregado) {
     const estado = (0, onboarding_1.lerOnboarding)(carregado.raiz);
@@ -315,6 +347,7 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
                     : 'files (fallback honesto: handoff por arquivos, ponteiro path#ancora)',
             correcao: estado.pedido === 'orkmind' && estado.efetivo === 'files' ? estado.correcao : undefined,
         });
+        checks.push(checarChaveDeEmbedding(context.loaded));
         // Bloco B3: a fila de rate limit e estado do mundo, nao detalhe interno. Uma fase
         // esperando janela e uma fase que NAO esta rodando, e quem olha o doctor precisa
         // saber disso antes de concluir que a thread travou.

package/dist/entrega-pr.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeDaEntrega = mergeDaEntrega;
 exports.registrarEntregaPorPr = registrarEntregaPorPr;
+exports.registrarEntregaExternaPorPr = registrarEntregaExternaPorPr;
 exports.registrarEntregasPorPr = registrarEntregasPorPr;
 /**
  * I-57 (RM-008, fatia 2): a entrega feita por PR tambem prova entrega para o MASTER.
@@ -35,6 +36,18 @@ function mergeDaEntrega(raiz, thread, remoto, base) {
     }
     return null;
 }
+/**
+ * A thread chega ao SHIP quando o ciclo dela tem SHIP, e so AVANCA: o segundo PR da mesma entrega (os
+ * dois sites da ork-siteshomesco, por exemplo) com a thread ja no MASTER nao a devolve ao SHIP (achado S9).
+ */
+function avancarParaShip(raiz, threadId) {
+    const atualizada = (0, thread_1.lerThread)(raiz, threadId);
+    const fases = atualizada.fases ?? [];
+    if (!fases.includes('SHIP') || fases.indexOf(atualizada.faseAtual) >= fases.indexOf('SHIP'))
+        return;
+    atualizada.faseAtual = 'SHIP';
+    (0, thread_1.gravarThread)(raiz, atualizada);
+}
 function resultado(thread, acao, motivo, extra = {}) {
     return { thread, acao, motivo, mergeSha: null, headSha: null, ci: null, ...extra };
 }
@@ -85,15 +98,106 @@ function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
         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);
-    }
+    avancarParaShip(raiz, threadId);
     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 });
 }
+const ghApi = (caminho) => (0, util_1.exec)('gh', ['api', caminho, '-H', 'Accept: application/vnd.github+json'], process.cwd(), 120000);
+function lerJson(r) {
+    if (!r.ok)
+        return null;
+    try {
+        return JSON.parse(r.stdout);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * `ork ship registrar-pr <thread> --repo <dono/nome> --pr <n>`: a thread que entrega por PR em outro
+ * repositorio (os sites, por exemplo) nao tinha como virar `ship_done`, e a entrega virava decisao. A
+ * exigencia e a mesma do caminho local: o merge dentro da ponta da base (pela API do GitHub, porque o
+ * repositorio nao e remoto deste checkout) e o check declarado verde no head do PR. O repositorio precisa
+ * estar declarado no manifesto; e o dono que diz onde, e com que check, a entrega vale. Idempotente.
+ */
+function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
+    const raiz = carregado.raiz, repo = opcoes.repositorio, n = opcoes.pr;
+    const gh = opcoes.executorGitHub ?? ghApi;
+    const declarados = carregado.manifesto.ci.external_repositories;
+    if (!Object.hasOwn(declarados, repo)) {
+        return resultado(threadId, 'recusada', `o repositorio ${repo} nao esta declarado em ci.external_repositories do orkastery.yaml`);
+    }
+    if (!Number.isSafeInteger(n) || n < 1)
+        return resultado(threadId, 'recusada', `--pr precisa ser o numero do PR, recebido ${String(n)}`);
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    if (thread.status === 'fechada')
+        return resultado(threadId, 'ja-registrada', 'thread ja fechada');
+    const dir = (0, thread_1.dirThread)(raiz, threadId);
+    if ((0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && e.repositorio === repo && e.pr === n)) {
+        return resultado(threadId, 'ja-registrada', `o PR #${n} de ${repo} ja tem ship_done`);
+    }
+    const pr = lerJson(gh(`repos/${repo}/pulls/${n}`));
+    if (!pr)
+        return resultado(threadId, 'recusada', `a consulta do PR #${n} de ${repo} ao GitHub falhou`);
+    const mergeSha = typeof pr.merge_commit_sha === 'string' && /^[0-9a-f]{40}$/.test(pr.merge_commit_sha) ? pr.merge_commit_sha : null;
+    const headSha = typeof pr.head?.sha === 'string' && /^[0-9a-f]{40}$/.test(pr.head.sha) ? pr.head.sha : null;
+    const base = typeof pr.base?.ref === 'string' && /^[A-Za-z0-9._/-]{1,200}$/.test(pr.base.ref) ? pr.base.ref : null;
+    if (pr.merged !== true || !mergeSha || !headSha || !base) {
+        return resultado(threadId, 'sem-merge', `o PR #${n} de ${repo} nao esta mesclado`);
+    }
+    // Achado A4 do CHECK: o PR precisa ser DESTA thread e ter entrado na branch padrao do repositorio. Sem o
+    // vinculo, qualquer PR mesclado do repositorio viraria entrega de qualquer thread; sem a base, um PR
+    // empilhado numa branch de feature contaria como entrega.
+    const vinculo = [pr.title, pr.body, pr.head?.ref].filter((x) => typeof x === 'string')
+        // N4 do CHECK 2: a branch do proprio ork e `ork/<thread>-<variante>`, entao o hifen depois do id vale;
+        // letra ou digito colado nao (outro id). Sem diferenciar maiusculas.
+        .some((x) => new RegExp(`(^|[^a-z0-9-])${threadId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![a-z0-9])`, 'i').test(x));
+    if (!vinculo) {
+        return resultado(threadId, 'recusada', `o PR #${n} de ${repo} nao cita a thread ${threadId} no titulo, no corpo nem na branch`, { mergeSha, headSha });
+    }
+    const repositorio = lerJson(gh(`repos/${repo}`));
+    if (!repositorio)
+        return resultado(threadId, 'recusada', `a consulta de ${repo} ao GitHub falhou`, { mergeSha, headSha });
+    if (repositorio.default_branch !== base) {
+        return resultado(threadId, 'recusada', `o PR #${n} entrou em ${base}, e a branch padrao de ${repo} e ${repositorio.default_branch ?? 'desconhecida'}`, { mergeSha, headSha });
+    }
+    // A ponta da base AGORA, e o merge dentro dela: o push provado, pela mesma pergunta do ls-remote.
+    const ramo = lerJson(gh(`repos/${repo}/branches/${encodeURIComponent(base)}`));
+    const ponta = typeof ramo?.commit?.sha === 'string' && /^[0-9a-f]{40}$/.test(ramo.commit.sha) ? ramo.commit.sha : '';
+    const comparacao = ponta ? lerJson(gh(`repos/${repo}/compare/${mergeSha}...${ponta}`)) : null;
+    if (!ponta || !comparacao || !['ahead', 'identical'].includes(String(comparacao.status))) {
+        return resultado(threadId, 'recusada', `o merge ${mergeSha.slice(0, 7)} nao esta na ponta de ${repo}:${base}`, { mergeSha, headSha });
+    }
+    const check = declarados[repo];
+    const ci = check ? (0, ci_1.consultarCiDoRepositorio)(repo, headSha, check, opcoes.executorCi) : null;
+    if (ci && !ci.ok) {
+        return resultado(threadId, 'recusada', `sem CI verde no head do PR: ${ci.detail}`, { mergeSha, headSha, ci });
+    }
+    (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipConcluido, {
+        de: thread.base?.branch ?? null,
+        para: `${repo}:${base}`,
+        repositorio: repo,
+        pr: n,
+        url: pr.html_url ?? `https://github.com/${repo}/pull/${n}`,
+        shaDe: headSha,
+        mergeSha,
+        jaIncorporado: true,
+        remoto: `github:${repo}`,
+        shaRemoto: ponta,
+        pushVerificado: true,
+        fonteDaProva: `gh api repos/${repo}/compare/${mergeSha}...${ponta} (status ${String(comparacao.status)}; ponta de ${base} por gh api repos/${repo}/branches/${base})`,
+        autorizadoPor: ci ? 'merge de PR com o CI independente verde no SHA exato' : 'merge de PR em repositorio externo declarado sem CI no manifesto',
+        tipoDeAutorizacao: 'pr-externo',
+        modo: thread.modo,
+        tag: (0, modos_1.tagDoModo)(thread.modo),
+        evidencia: { viaPr: true, externo: true, ciExigido: !!ci, ci: ci ? { state: ci.state, context: ci.context, url: ci.url, sha: ci.sha } : null },
+    });
+    avancarParaShip(raiz, threadId);
+    if (opcoes.publicar !== false)
+        (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
+    return resultado(threadId, 'registrou', `ship_done pelo merge ${mergeSha.slice(0, 7)} do PR #${n} de ${repo}`, { mergeSha, headSha, 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';

package/dist/experiencia-instalacao.js

@@ -0,0 +1,256 @@
+"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.FIM_EXPERIENCIA = exports.INICIO_EXPERIENCIA = void 0;
+exports.caminhoSeguro = caminhoSeguro;
+exports.planejarExperiencia = planejarExperiencia;
+exports.aplicarExperiencia = aplicarExperiencia;
+/** Bloco próprio nos arquivos lidos pelo host. Nunca altera o bloco de ork init. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+exports.INICIO_EXPERIENCIA = '<!-- orkastery:experiencia:begin -->';
+exports.FIM_EXPERIENCIA = '<!-- orkastery:experiencia:end -->';
+const CONTRATO = 'ork.experiencia-install/v1';
+const LINHA_DO_DIRETORIO = /^Se ativo, leia a skill selecionada pelo campo skill no diretório (".*")\.$/;
+const conflito = () => { throw Error('experiencia.bloco.conflict: bloco ou recibo alterado/duplicado; preserve os arquivos e revise a instalação'); };
+/** Recusa symlinks e hardlinks em qualquer componente antes da leitura/escrita. */
+function caminhoSeguro(projeto, arquivo) {
+    if (fs.realpathSync(projeto) !== projeto || !arquivo.startsWith(projeto + path.sep))
+        throw Error('experiencia.path.unsafe');
+    let atual = projeto;
+    const partes = path.relative(projeto, arquivo).split(path.sep);
+    for (let i = 0; i < partes.length; i++) {
+        atual = path.join(atual, partes[i]);
+        const s = fs.lstatSync(atual, { throwIfNoEntry: false });
+        if (!s)
+            continue;
+        if (s.isSymbolicLink() || (i < partes.length - 1 ? !s.isDirectory() : !s.isFile() || s.nlink !== 1))
+            throw Error('experiencia.path.unsafe');
+    }
+}
+function ler(projeto, arquivo) {
+    caminhoSeguro(projeto, arquivo);
+    return fs.existsSync(arquivo) ? fs.readFileSync(arquivo) : null;
+}
+function iguais(a, b) { return a === null ? b === null : b !== null && a.equals(b); }
+function contar(b, texto) {
+    let n = 0, i = 0;
+    while ((i = b.indexOf(texto, i)) >= 0) {
+        n++;
+        i += Buffer.byteLength(texto);
+    }
+    return n;
+}
+function decodificar(s) {
+    if (typeof s !== 'string')
+        return conflito();
+    const b = Buffer.from(s, 'base64');
+    if (b.toString('base64') !== s)
+        return conflito();
+    return b;
+}
+const eolDe = (b) => b.includes('\r\n') ? '\r\n' : '\n';
+/** O caminho vai relativo ao projeto: o arquivo de instruções costuma ser versionado. */
+function nucleoDoBloco(skill, eol) {
+    return Buffer.from([exports.INICIO_EXPERIENCIA,
+        '## Experiência de orquestração',
+        'Consulte `ork experiencia show --json` neste projeto. Se experience for false, não ative o pacote.',
+        `Se ativo, leia a skill selecionada pelo campo skill no diretório ${JSON.stringify(skill)}.`,
+        'As preferências são dados do núcleo; preserve gates, proveniência humana e permissões do host.',
+        exports.FIM_EXPERIENCIA, ''].join(eol));
+}
+/**
+ * Bloco sem recibo (clone novo, `.orkastery/` apagado) só é adotado quando é exatamente o texto
+ * que esta versão ou a anterior geram, com qualquer diretório; qualquer outra edição é conflito.
+ */
+function reconhecerBloco(antes) {
+    if (contar(antes, exports.INICIO_EXPERIENCIA) !== 1 || contar(antes, exports.FIM_EXPERIENCIA) !== 1)
+        return null;
+    const inicio = antes.indexOf(exports.INICIO_EXPERIENCIA), marcaFim = antes.indexOf(exports.FIM_EXPERIENCIA);
+    if (marcaFim < inicio || (inicio > 0 && antes[inicio - 1] !== 10))
+        return null;
+    let fim = marcaFim + Buffer.byteLength(exports.FIM_EXPERIENCIA);
+    const eol = eolDe(antes.subarray(inicio, fim));
+    if (antes.subarray(fim, fim + eol.length).toString() === eol)
+        fim += eol.length;
+    const texto = antes.subarray(inicio, fim);
+    const linha = texto.toString('utf8').split(eol)[3] ?? '';
+    const m = LINHA_DO_DIRETORIO.exec(linha);
+    let skill;
+    try {
+        skill = m ? JSON.parse(m[1]) : undefined;
+    }
+    catch {
+        return null;
+    }
+    if (typeof skill !== 'string' || /[\r\n`]/.test(skill))
+        return null;
+    const esperado = nucleoDoBloco(skill, eol);
+    if (!texto.equals(esperado) && !texto.equals(esperado.subarray(0, esperado.length - eol.length)))
+        return null;
+    // Uma linha em branco antes do bloco é o separador que a instalação põe depois de uma linha.
+    const sep = Buffer.from(eol);
+    const separador = inicio >= 2 * sep.length && antes.subarray(inicio - sep.length, inicio).equals(sep) &&
+        antes[inicio - sep.length - 1] === 10 ? sep : Buffer.alloc(0);
+    return { inicio, fim, separador, eol, doRecibo: false };
+}
+/**
+ * Remove o bloco e, se ainda intacto, o separador. O separador de uma quebra só sai quando a linha
+ * anterior continua terminada; o de duas, quando a última linha do conteúdo original continua sem
+ * quebra. Conteúdo externo depois do bloco não se funde à última linha do prefixo.
+ */
+function removerBloco(antes, bloco) {
+    let inicio = bloco.inicio;
+    const sep = bloco.separador, antesDoSep = bloco.inicio - sep.length;
+    if (sep.length && antesDoSep > 0 && antes.subarray(antesDoSep, bloco.inicio).equals(sep)) {
+        const terminaEmLinha = antes[antesDoSep - 1] === 10;
+        if ((contar(sep, '\n') === 1) === terminaEmLinha)
+            inicio = antesDoSep;
+    }
+    const prefixo = antes.subarray(0, inicio), sufixo = antes.subarray(bloco.fim);
+    const juncao = prefixo.length && prefixo.at(-1) !== 10 && sufixo.length ? Buffer.from(bloco.eol) : Buffer.alloc(0);
+    return Buffer.concat([prefixo, juncao, sufixo]);
+}
+/** Planejamento puro em relação ao disco: dry-run e preflight usam o mesmo contrato. */
+function planejarExperiencia(projeto, host, skill) {
+    projeto = fs.realpathSync(path.resolve(projeto));
+    if (!['claude-code', 'codex'].includes(host))
+        throw Error('experiencia.host.unsupported');
+    if (skill !== null && /[\r\n`]/.test(skill))
+        throw Error('experiencia.skill.invalid');
+    const arquivo = path.join(projeto, host === 'codex' ? 'AGENTS.md' : 'CLAUDE.md');
+    const reciboPath = path.join(projeto, '.orkastery', 'experiencia', host + '.json');
+    const antes = ler(projeto, arquivo), bytesRecibo = ler(projeto, reciboPath);
+    let recibo = null;
+    if (bytesRecibo) {
+        try {
+            recibo = JSON.parse(bytesRecibo.toString('utf8'));
+        }
+        catch {
+            conflito();
+        }
+        if (!recibo || recibo.contrato !== CONTRATO || recibo.host !== host)
+            return conflito();
+        if (recibo.anterior !== null)
+            decodificar(recibo.anterior);
+    }
+    const marcas = antes ? contar(antes, exports.INICIO_EXPERIENCIA) + contar(antes, exports.FIM_EXPERIENCIA) : 0;
+    // Sem marcas, um recibo que sobrou (arquivo apagado ou bloco tirado à mão) não descreve nada.
+    let bloco = null;
+    if (antes && marcas) {
+        if (recibo) {
+            const adicao = decodificar(recibo.adicao), corte = adicao.indexOf(exports.INICIO_EXPERIENCIA);
+            if (contar(adicao, exports.INICIO_EXPERIENCIA) !== 1 || contar(adicao, exports.FIM_EXPERIENCIA) !== 1 || corte < 0)
+                return conflito();
+            const nucleo = adicao.subarray(corte), inicio = antes.indexOf(nucleo);
+            if (marcas === 2 && inicio >= 0) {
+                bloco = { inicio, fim: inicio + nucleo.length, separador: adicao.subarray(0, corte), eol: eolDe(nucleo), doRecibo: true };
+            }
+        }
+        bloco ??= reconhecerBloco(antes);
+        if (!bloco)
+            return conflito();
+    }
+    let depois = antes, proximoRecibo = null;
+    if (skill !== null) {
+        let separador, nucleo, anterior;
+        if (antes && bloco) {
+            // Atualização no lugar: o que está antes e depois do bloco, inclusive edição externa, fica.
+            nucleo = nucleoDoBloco(skill, bloco.eol);
+            separador = bloco.separador;
+            depois = Buffer.concat([antes.subarray(0, bloco.inicio), nucleo, antes.subarray(bloco.fim)]);
+            // Adotado sem recibo: se só havia o bloco, o arquivo conta como criado pelo pacote.
+            const semBloco = removerBloco(antes, bloco);
+            anterior = bloco.doRecibo ? recibo.anterior : semBloco.length ? semBloco.toString('base64') : null;
+        }
+        else {
+            const base = antes ?? Buffer.alloc(0), eol = eolDe(base);
+            nucleo = nucleoDoBloco(skill, eol);
+            separador = Buffer.from(base.length ? (base.at(-1) === 10 ? eol : eol + eol) : '');
+            depois = Buffer.concat([base, separador, nucleo]);
+            anterior = antes?.toString('base64') ?? null;
+        }
+        proximoRecibo = Buffer.from(JSON.stringify({ contrato: CONTRATO, host, anterior,
+            adicao: Buffer.concat([separador, nucleo]).toString('base64'),
+        }, null, 2) + '\n');
+    }
+    else if (antes && bloco) {
+        depois = removerBloco(antes, bloco);
+        // Vazio só some quando o arquivo não existia (recibo) ou quando, sem recibo, só havia o bloco.
+        if (depois.length === 0 && (recibo ? recibo.anterior === null : true))
+            depois = null;
+    }
+    const mudancas = [{ arquivo, antes, depois }, { arquivo: reciboPath, antes: bytesRecibo, depois: proximoRecibo }]
+        .filter(m => !iguais(m.antes, m.depois));
+    return { projeto, host, acao: skill === null ? 'remover' : 'instalar', mudancas };
+}
+/** Revalida o plano inteiro; falha de gravação restaura as mudanças já aplicadas. */
+function aplicarExperiencia(plano) {
+    for (const m of plano.mudancas)
+        if (!iguais(ler(plano.projeto, m.arquivo), m.antes))
+            throw Error('experiencia.plan.stale');
+    const aplicadas = [];
+    const gravar = (arquivo, conteudo) => {
+        caminhoSeguro(plano.projeto, arquivo);
+        if (conteudo === null) {
+            fs.unlinkSync(arquivo);
+            return;
+        }
+        fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+        const tmp = arquivo + '.' + (0, node_crypto_1.randomUUID)() + '.tmp';
+        try {
+            // Arquivo novo segue o umask, como um CLAUDE.md criado à mão.
+            const modo = fs.statSync(arquivo, { throwIfNoEntry: false })?.mode ?? 0o666;
+            fs.writeFileSync(tmp, conteudo, { flag: 'wx', mode: modo });
+            fs.renameSync(tmp, arquivo);
+        }
+        finally {
+            if (fs.existsSync(tmp))
+                fs.unlinkSync(tmp);
+        }
+    };
+    try {
+        for (const m of plano.mudancas) {
+            gravar(m.arquivo, m.depois);
+            aplicadas.push(m);
+        }
+    }
+    catch (e) {
+        for (const m of aplicadas.reverse())
+            gravar(m.arquivo, m.antes);
+        throw e;
+    }
+}