@orkastery/cli 0.4.3 → 0.5.1

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 };
 }
@@ -68,6 +81,10 @@ function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
     if (ci.required && !ci.ok) {
         return resultado(threadId, 'recusada', `sem CI verde no head do PR: ${ci.detail}`, { ...merge, ci });
     }
+    // RM-037 (fatia 3, defeito 6): o ensaio confere tudo e para aqui, sem ledger, fase nem fabrica.
+    if (opcoes.dryRun) {
+        return resultado(threadId, 'registraria', `ensaio: registraria ship_done pelo merge ${merge.mergeSha.slice(0, 7)} do PR (nada gravado)`, { ...merge, ci });
+    }
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipConcluido, {
         de: thread.base?.branch ?? null,
         para: base,
@@ -85,15 +102,109 @@ 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 });
+    }
+    if (opcoes.dryRun) {
+        return resultado(threadId, 'registraria', `ensaio: registraria ship_done pelo merge ${mergeSha.slice(0, 7)} do PR #${n} de ${repo} (nada gravado)`, { 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;
+    }
+}

package/dist/experiencia.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizarIdioma = normalizarIdioma;
+exports.validarPreferencias = validarPreferencias;
+exports.idiomaDoSistema = idiomaDoSistema;
+exports.resolverExperiencia = resolverExperiencia;
+/** Preferências públicas da experiência. Consulta não grava respostas nem autoria. */
+const horario_1 = require("./horario");
+function normalizarIdioma(valor) {
+    if (typeof valor !== 'string' || !valor.trim())
+        return undefined;
+    try {
+        return Intl.getCanonicalLocales(valor.trim())[0];
+    }
+    catch {
+        return undefined;
+    }
+}
+function validarPreferencias(valor) {
+    if (!valor || typeof valor !== 'object' || Array.isArray(valor))
+        throw Error('experiencia.config.invalid: owner deve ser um objeto');
+    const v = valor, resultado = {};
+    if (v.language !== undefined) {
+        const idioma = normalizarIdioma(v.language);
+        if (!idioma)
+            throw Error('experiencia.config.invalid: owner.language exige locale BCP-47');
+        resultado.language = idioma;
+    }
+    if (v.timezone !== undefined) {
+        const fuso = (0, horario_1.normalizarFuso)(v.timezone);
+        if (!fuso)
+            throw Error('experiencia.config.invalid: owner.timezone exige fuso IANA');
+        resultado.timezone = fuso;
+    }
+    if (v.depth !== undefined) {
+        if (v.depth !== 'curta' && v.depth !== 'detalhada')
+            throw Error('experiencia.config.invalid: owner.depth exige curta ou detalhada');
+        resultado.depth = v.depth;
+    }
+    if (v.experience !== undefined) {
+        if (typeof v.experience !== 'boolean')
+            throw Error('experiencia.config.invalid: owner.experience exige booleano');
+        resultado.experience = v.experience;
+    }
+    return resultado;
+}
+/** C, POSIX e und (raiz do ICU) dizem que o sistema não escolheu idioma: vale o padrão. */
+const SEM_IDIOMA = new Set(['c', 'posix', 'und']);
+function idiomaEscolhido(valor) {
+    const idioma = normalizarIdioma(valor);
+    return idioma && !SEM_IDIOMA.has(idioma.toLowerCase().split('-')[0]) ? idioma : undefined;
+}
+function idiomaDoSistema(env = process.env, doIntl = () => Intl.DateTimeFormat().resolvedOptions().locale) {
+    const locale = env.LC_ALL || env.LC_MESSAGES || env.LANG;
+    return idiomaEscolhido(locale?.split(/[.@]/)[0].replace(/_/g, '-')) ?? idiomaEscolhido(doIntl()) ?? 'en-US';
+}
+function resolverExperiencia(owner = {}, sistema = { language: idiomaDoSistema(), timezone: (0, horario_1.fusoDoSistema)() }) {
+    const p = validarPreferencias(owner);
+    const language = p.language ?? normalizarIdioma(sistema.language) ?? 'en-US';
+    return {
+        language, timezone: p.timezone ?? (0, horario_1.normalizarFuso)(sistema.timezone) ?? 'UTC',
+        depth: p.depth ?? 'curta', experience: p.experience ?? true,
+        skill: language.toLowerCase().startsWith('pt-') || language === 'pt'
+            ? 'orchestration-experience-pt-br' : 'orchestration-experience',
+        origem: {
+            language: p.language === undefined ? 'sistema' : 'manifesto',
+            timezone: p.timezone === undefined ? 'sistema' : 'manifesto',
+            depth: p.depth === undefined ? 'padrao' : 'manifesto',
+            experience: p.experience === undefined ? 'padrao' : 'manifesto',
+        },
+    };
+}

package/dist/fabrica-estado.js

@@ -33,11 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PULSACAO_MS = exports.BRANCH_DA_FABRICA = exports.CONTRATO_MAQUINA = void 0;
+exports.LIMIAR_SEM_BATIDA_MS = exports.PULSACAO_MS = exports.DIR_DA_FABRICA = exports.BRANCH_DA_FABRICA = exports.CONTRATO_MAQUINA = void 0;
+exports.despachoDaThread = despachoDaThread;
+exports.runtimeDaThread = runtimeDaThread;
 exports.arquivoDaMaquina = arquivoDaMaquina;
 exports.entregasNaBase = entregasNaBase;
 exports.retratoDaMaquina = retratoDaMaquina;
 exports.assinaturaDoRetrato = assinaturaDoRetrato;
+exports.estadoValido = estadoValido;
 exports.lerFabrica = lerFabrica;
 exports.publicarMaquina = publicarMaquina;
 exports.removerMaquina = removerMaquina;
@@ -70,21 +73,50 @@ const monitor_lock_1 = require("./monitor-lock");
 const board_1 = require("./board");
 const estado_thread_1 = require("./estado-thread");
 const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
 const orquestracao_1 = require("./orquestracao");
+const parado_no_condutor_1 = require("./parado-no-condutor");
 const roadmap_reservas_1 = require("./roadmap-reservas");
+const thread_1 = require("./thread");
 const util_1 = require("./util");
 const versao_1 = require("./versao");
 exports.CONTRATO_MAQUINA = 'ork.fabrica-maquina/v1';
 exports.BRANCH_DA_FABRICA = 'ork/fabrica-estado';
-const DIR = 'maquinas';
+/** O diretorio dos retratos na branch; a leitura sem clone (RM-054) le o mesmo. */
+exports.DIR_DA_FABRICA = 'maquinas';
+const DIR = exports.DIR_DA_FABRICA;
 const PAINEL = 'FABRICA.md';
 const PREFIXO = 'fabrica';
 const TENTATIVAS = 5;
 /** Retrato igual ao ultimo publicado so volta ao remoto depois disto: e o sinal de vida da maquina. */
 exports.PULSACAO_MS = 60 * 60 * 1000;
+/**
+ * Maquina sem retrato novo ha mais disto esta sem batida: o mesmo limiar da rede (RM-053, `SEM_BATIDA_MS`).
+ * RM-037 (fatia 4): mora aqui, junto da pulsacao, porque o status do roadmap tambem o le; o panorama da
+ * rede o reexporta.
+ */
+exports.LIMIAR_SEM_BATIDA_MS = 3 * 60 * 60 * 1000;
 const ARQUIVO_DA_MARCA = 'fabrica-publicada.json';
 const ARQUIVO_DO_LOG = 'fabrica.log';
+/** O trio do ultimo `phase_dispatch` do ledger da thread; tudo `null` quando nao ha despacho legivel. */
+function despachoDaThread(dir) {
+    let ultimo;
+    try {
+        ultimo = [...(0, ledger_1.lerLedger)(dir)].reverse().find((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada);
+    }
+    catch {
+        ultimo = undefined;
+    }
+    const campo = (v) => (typeof v === 'string' && v.trim() ? curto(v, 40) : null);
+    return { runtime: campo(ultimo?.runtime), modelo: campo(ultimo?.model), esforco: campo(ultimo?.effort) };
+}
+/** `claude-bg opus/xhigh`: o runtime com o modelo e o esforco, para as colunas do texto. */
+function runtimeDaThread(t) {
+    if (!t.runtime && !t.modelo)
+        return '-';
+    return [t.runtime ?? '?', [t.modelo, t.esforco].filter(Boolean).join('/')].filter(Boolean).join(' ');
+}
 const curto = (texto, teto = 120) => {
     const limpo = String(texto ?? '').replace(/\s+/g, ' ').trim();
     return limpo.length > teto ? `${limpo.slice(0, teto - 3)}...` : limpo;
@@ -101,7 +133,11 @@ function arquivoDaMaquina(maquina) {
  * entrega usa, o mesmo fato que o `ork docs sincronizar` le. Um `git log` so, para todas.
  */
 function entregasNaBase(raiz, base, remoto = 'origin') {
-    const ref = (0, branch_de_estado_1.git)(raiz, ['rev-parse', '--verify', '--quiet', `refs/remotes/${remoto}/${base}`]).ok ? `${remoto}/${base}` : base;
+    // A base vem do manifesto: a ref vai sempre qualificada (`refs/...`), e um valor como
+    // `--output=<arquivo>` nunca vira opcao do `git log`, em qualquer versao do git (RM-054, CHECK).
+    // Na ordem: a copia remota da base, a branch local, e a base escrita como remota (`origin/main`).
+    const candidatas = [`refs/remotes/${remoto}/${base}`, `refs/heads/${base}`, `refs/remotes/${base}`];
+    const ref = candidatas.find((c) => (0, branch_de_estado_1.git)(raiz, ['rev-parse', '--verify', '--quiet', c]).ok) ?? candidatas[1];
     // Regex basica do git: o `(` e literal.
     const r = (0, branch_de_estado_1.git)(raiz, ['log', ref, '--format=%h%x09%s', '--grep=^ship(']);
     const entregas = new Map();
@@ -125,16 +161,28 @@ function retratoDaMaquina(carregado, opcoes = {}) {
     const linhas = new Map(monitor.linhas.map((l) => [l.thread, l]));
     const entregas = entregasNaBase(raiz, carregado.manifesto.worktree.base_branch, remoto);
     const itemDaThread = new Map((0, roadmap_reservas_1.reservasLocais)(raiz, remoto).filter((r) => r.thread).map((r) => [r.thread, r.item]));
-    const threads = itens.map(({ thread: t }) => {
-        const pausa = linhas.get(t.id)?.pausas[0];
+    const threads = itens.map(({ thread: t, raiz: raizDoPerfil }) => {
         const entregue = entregas.get(t.id) ?? null;
-        const esperaVoce = !entregue && linhas.get(t.id)?.precisaDeHumano === true;
+        // RM-037 (fatia 4): o fim de turno sem pergunta e do condutor, e as outras maquinas nao o leem como espera
+        // do dono. Sai so a pausa que o observador abriu nele; outra pausa da thread continua contando.
+        let espera = null;
+        try {
+            espera = (0, parado_no_condutor_1.esperaDoCondutor)(t, (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raizDoPerfil, t.id)), quando);
+        }
+        catch {
+            espera = null;
+        }
+        const pausas = (linhas.get(t.id)?.pausas ?? []).filter((p) => !(espera && p.motivo === 'human.pending' && p.fonte === 'ledger' &&
+            p.fase === (espera.fase ?? t.faseAtual)));
+        const pausa = pausas[0];
+        const esperaVoce = !entregue && pausas.some((p) => p.sessaoViva !== true);
         return {
             id: t.id, nome: curto(t.nome, 100), modo: (0, modos_1.tagDoModo)(t.modo), fase: t.faseAtual, status: t.status,
             roadmap: t.roadmap ?? itemDaThread.get(t.id) ?? null, branch: t.base?.branch ?? null,
             atualizadaEm: t.atualizadaEm ?? null, entregue,
             esperaVoce, pergunta: esperaVoce && pausa ? curto(pausa.pausaSobre || pausa.detalhe) : null,
             paradaDesde: esperaVoce && pausa ? pausa.desdeEm : null,
+            ...despachoDaThread((0, thread_1.dirThread)(raizDoPerfil, t.id)),
         };
     }).sort((a, b) => a.id.localeCompare(b.id));
     const eu = (0, roadmap_reservas_1.quemSouEu)(raiz, { por: opcoes.por, maquina: opcoes.maquina });
@@ -146,6 +194,7 @@ function assinaturaDoRetrato(e) {
     const { publicadoEm: _publicadoEm, ...resto } = e;
     return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(resto)).digest('hex');
 }
+/** O retrato so vale inteiro: e o filtro da leitura pelo clone e pela forja (RM-054). */
 function estadoValido(bruto) {
     const e = bruto;
     return !!e && e.contrato === exports.CONTRATO_MAQUINA && typeof e.maquina === 'string' && !!e.maquina.trim() &&
@@ -278,8 +327,8 @@ function blocoDaMaquina(m, eu) {
         `${vivas.length} thread(s) ativa(s)` + (entregues ? `, ${entregues} entregue(s) sem MASTER` : '');
     if (vivas.length === 0)
         return [cabeca];
-    return [cabeca, ...tabela(['THREAD', 'MODO', 'FASE', 'ITEM', 'ESPERA VOCE'], vivas.map((t) => [
-            t.id, t.modo, t.fase, t.roadmap ?? '-', t.esperaVoce ? `sim: ${curto(t.pergunta ?? 'veredito', 40)}` : '-',
+    return [cabeca, ...tabela(['THREAD', 'MODO', 'FASE', 'RUNTIME', 'ITEM', 'ESPERA VOCE'], vivas.map((t) => [
+            t.id, t.modo, t.fase, runtimeDaThread(t), t.roadmap ?? '-', t.esperaVoce ? `sim: ${curto(t.pergunta ?? 'veredito', 40)}` : '-',
         ]))];
 }
 /** `ork fabrica`: todas as maquinas. */
@@ -315,15 +364,17 @@ function painelDaFabricaEmMarkdown(maquinas) {
         'O que cada máquina está conduzindo agora. Gerado pelo `ork fabrica publicar`; não edite à mão.',
         'Antes de pegar um item do roadmap: `ork roadmap reservas`.',
         '',
-        '| Máquina | Thread | Modo | Fase | Item | Espera você | Publicado |',
-        '| --- | --- | --- | --- | --- | --- | --- |',
+        '| Máquina | Thread | Modo | Fase | Runtime | Item | Espera você | Publicado |',
+        '| --- | --- | --- | --- | --- | --- | --- | --- |',
     ];
     const vivas = maquinas.flatMap((m) => ativas(m).map((t) => ({ m, t })));
     if (vivas.length === 0)
-        linhas.push('| — | nenhuma thread ativa | — | — | — | — | — |');
+        linhas.push('| — | nenhuma thread ativa | — | — |  | — | — | — |');
     for (const { m, t } of vivas) {
         const pergunta = t.esperaVoce ? `sim: ${curto(t.pergunta ?? 'veredito', 60).replace(/\|/g, '/')}` : '—';
-        linhas.push(`| ${m.maquina} | ${t.id} | ${t.modo} | ${t.fase} | ${t.roadmap ?? '—'} | ${pergunta} | ${(0, horario_1.formatarDataHora)(m.publicadoEm)} |`);
+        // RM-037 (sugestao 6 do CHECK 1): a celula sem despacho diz isso, sem travessao novo.
+        const runtime = t.runtime || t.modelo ? runtimeDaThread(t).replace(/\|/g, '/') : 'sem despacho';
+        linhas.push(`| ${m.maquina} | ${t.id} | ${t.modo} | ${t.fase} | ${runtime} | ${t.roadmap ?? '—'} | ${pergunta} | ${(0, horario_1.formatarDataHora)(m.publicadoEm)} |`);
     }
     return [...linhas, '', (0, horario_1.legendaDoFuso)(), ''].join('\n');
 }