@orkastery/cli 0.5.1 → 0.5.3

package/dist/canarios-rm057.js

@@ -0,0 +1,149 @@
+"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.fxPedidoColado = exports.PROMPTS_DE_CONDUCAO = exports.FRASE_DO_PEDIDO_COLADO = exports.PEDIDO_COLADO_DO_INCIDENTE = void 0;
+/**
+ * RM-057 (fatia 2): o canario do incidente de 01/10/2026.
+ *
+ * Na noite de 01 para 02/10 o condutor recebeu, colado, o pedido do dono com push e merge
+ * autorizados ate um horario, parou para pedir um "confirmo" em texto livre e a fabrica ficou mais
+ * de 10 h sem produzir. O canario refaz a conducao inteira em sandbox SIMULADO e exige que o mesmo
+ * pedido colado siga sem parar:
+ *
+ *   1. o modo sai da #TAG do texto colado (`#Auto`), pelo nucleo;
+ *   2. o `#Auto` nao abre pausa humana na fase;
+ *   3. a duvida dentro da autorizacao vira decisao informada (`ork decisao registrar`), sem pergunta;
+ *   4. o "confirmo" em texto livre que o condutor tentaria abrir e recusado com
+ *      `hitl.selecao.texto-livre`, sem gravar nada no ledger;
+ *   5. o pulse nao mostra ninguem esperando o dono, e o tempo parado por HITL de conducao e zero;
+ *   6. os quatro adaptadores de conducao (Claude Code, Codex, Hermes e OpenClaw) dizem que o pedido
+ *      colado com autorizacao explicita vale como instrucao do dono.
+ *
+ * Nada aqui e resposta humana nem rede: e a forma da conducao, provada contra o codigo real.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const decisao_autonoma_1 = require("./decisao-autonoma");
+const hitl_contract_1 = require("./hitl-contract");
+const hitl_gates_1 = require("./hitl-gates");
+const ledger_1 = require("./ledger");
+const ledger_stats_1 = require("./ledger-stats");
+const modos_1 = require("./modos");
+const pulse_1 = require("./pulse");
+const sandbox_1 = require("./sandbox");
+const thread_1 = require("./thread");
+/** O pedido do dono como chegou colado no incidente, com a autorizacao explicita e o prazo. */
+exports.PEDIDO_COLADO_DO_INCIDENTE = '#Auto Conduza as threads RM-032, RM-056, RM-053, RM-040 e RM-055 no orkastery. ' +
+    'Push e merge autorizados até 02/10 às 12h. Não me pergunte nada: dúvida menor vira decisão registrada e segue.';
+/** A frase que os quatro adaptadores de conducao carregam desde a RM-057. */
+exports.FRASE_DO_PEDIDO_COLADO = 'o pedido que ele colou com autorização explícita vale como instrução dele';
+/** Onde cada host le a regra: o comando, as skills e as descricoes das tools do OpenClaw. */
+exports.PROMPTS_DE_CONDUCAO = [
+    'adapters/claude-code/commands/ork.md',
+    'adapters/codex/skills/ork/SKILL.md',
+    'adapters/hermes/skills/orkastery-devmaster/SKILL.md',
+    'adapters/openclaw/dist/index.js',
+];
+exports.fxPedidoColado = {
+    id: 'fx-pedido-colado',
+    sobre: 'SIMULADO: o pedido colado com autorização explícita segue sem parar (incidente de 01/10, RM-057)',
+    precisaDeGit: true,
+    rodar: (ctx) => {
+        const s = (0, sandbox_1.sandboxGit)('pedido-colado');
+        try {
+            const modo = (0, modos_1.extrairTagDoPedido)(exports.PEDIDO_COLADO_DO_INCIDENTE);
+            const t = (0, thread_1.novaThread)(s.carregado, { nome: 'pedido-colado', modo: modo ?? 'classic' }).thread;
+            const dir = (0, thread_1.dirThread)(s.dir, t.id);
+            (0, ledger_1.registrar)(dir, t.id, 'phase_result', { fase: t.faseAtual });
+            let semPausaDoModo = false;
+            try {
+                (0, hitl_gates_1.abrirPedidoGate)(s.dir, t.id);
+            }
+            catch (e) {
+                semPausaDoModo = /não prevê pausa/.test(e.message);
+            }
+            const decisao = (0, decisao_autonoma_1.registrarDecisao)(s.dir, t.id, {
+                decidido: 'Seguir com push e merge dentro da autorização colada', porque: 'o dono autorizou até 02/10 às 12h',
+                comoMudar: 'reverter o merge', custoDeReverter: { agora: 'um revert', depois: 'um revert' },
+                criterio: { tipo: 'ledger', referencia: `${t.id}#evento:1` }, quemDecidiu: 'canario-SIMULADO', evidencia: 'pedido colado',
+            });
+            const confirmo = {
+                contrato: hitl_contract_1.CONTRATO_HITL_V2, id: 'confirmo-SIMULADO', thread: t.id, fase: t.faseAtual, modo: t.modo,
+                criadoEm: new Date().toISOString(), profundidade: 'resumo', classe: 'pergunta',
+                alvo: { tipo: 'gate', sobre: 'premissas' }, motivo: 'human.pending', pergunta: 'Posso seguir com o push e o merge?',
+                alternativas: [
+                    { letra: 'a', texto: 'Seguir', acao: 'aprovar', consequencia: 'segue', recomendada: true, porque: 'autorizado no pedido' },
+                    { letra: 'b', texto: 'Parar', acao: 'recusar', consequencia: 'para' },
+                    { letra: 'c', texto: 'Esperar', acao: 'esperar', consequencia: 'fica' },
+                ],
+                corpo: ['Responda confirmo para eu continuar'], tipoDeResposta: 'aberta', irreversivel: false, codigo: 'K3F9',
+                prazo: new Date(Date.now() + 3_600_000).toISOString(), acaoPadraoAoExpirar: 'esperar',
+                respostaAceita: { tipo: 'texto', maxCaracteres: 200 },
+            };
+            const antes = (0, ledger_1.lerLedger)(dir).length;
+            let confirmoRecusado = 'aceito';
+            try {
+                (0, hitl_gates_1.registrarPedidoHitl)(s.dir, confirmo);
+            }
+            catch (e) {
+                confirmoRecusado = e instanceof hitl_contract_1.SelecaoRecusada ? e.motivo : `outro: ${e.message}`;
+            }
+            const nadaGravadoNaRecusa = (0, ledger_1.lerLedger)(dir).length === antes;
+            const pulse = (0, pulse_1.montarPulse)(s.carregado, { consulta: { ok: true, sessoes: [], detalhe: 'runtime SIMULADO' } });
+            const parado = (0, ledger_stats_1.coletarEstatisticas)(s.dir, { desde: '1h', thread: t.id }).hitlDeConducao;
+            // No dist do OpenClaw a frase e uma concatenacao de literais: as emendas `' + '` saem antes da busca.
+            const umaLinha = (x) => x.replace(/'\s*\+\s*'/g, '').replace(/\s+/g, ' ');
+            const adaptadoresComARegra = exports.PROMPTS_DE_CONDUCAO.filter((rel) => {
+                const arquivo = path.join(ctx.catalogo, rel);
+                return fs.existsSync(arquivo) && umaLinha(fs.readFileSync(arquivo, 'utf8')).includes(exports.FRASE_DO_PEDIDO_COLADO);
+            }).length;
+            return {
+                simulado: true,
+                modoDoPedido: modo,
+                semPausaDoModo,
+                decisaoInformada: decisao.pedido.classe === 'decidido',
+                confirmoRecusado,
+                nadaGravadoNaRecusa,
+                humanosNoPulse: pulse.resumo.humanos,
+                perguntasDeConducao: parado.pedidos,
+                tempoParadoMs: parado.paradoMs,
+                adaptadoresComARegra,
+            };
+        }
+        finally {
+            s.limpar();
+        }
+    },
+};

package/dist/canarios.js

@@ -71,6 +71,7 @@ const canarios_pulse_1 = require("./canarios-pulse");
 const canarios_sensores_1 = require("./canarios-sensores");
 const canarios_hitl_1 = require("./canarios-hitl");
 const canarios_i43_1 = require("./canarios-i43");
+const canarios_rm057_1 = require("./canarios-rm057");
 const objective_1 = require("./objective");
 const maestro_discovery_1 = require("./maestro-discovery");
 const maestro_cli_1 = require("./maestro-cli");
@@ -373,6 +374,7 @@ exports.CANARIOS = [
     canarios_sensores_1.CANARIO_SENSORES,
     ...canarios_hitl_1.CANARIOS_HITL,
     ...canarios_i43_1.CANARIOS_I43,
+    canarios_rm057_1.fxPedidoColado,
 ];
 /** Um canario por id, ou null quando a fixture aponta para um canario que nao existe. */
 function canarioPorId(id) {

package/dist/ci.js

@@ -46,6 +46,8 @@ exports.prepararBundleCi = prepararBundleCi;
 exports.bundleDaBranch = bundleDaBranch;
 exports.executarCiDaBranch = executarCiDaBranch;
 exports.executarBundleCi = executarBundleCi;
+/** GitHub CI como CHECK independente (I-12). */
+const branch_de_estado_1 = require("./branch-de-estado");
 const util_1 = require("./util");
 const worktree_1 = require("./worktree");
 const verify_1 = require("./verify");
@@ -73,9 +75,13 @@ const CASOS_DE_VERIFICADOR_COM_INTEGRACAO_LOCAL = [
     /verify-check-c2-b3\.cjs\s+channel-offer(?:\s|$)/,
     // I-38: a prova da busca por significado le a memoria do tenant pela DSN do manifesto.
     /prova-busca-semantica\.sh(?:\s|$)/,
+    // RM-038: a prova do universo da busca tambem le a memoria do tenant pela DSN do manifesto.
+    /prova-universo-da-busca\.cjs(?:\s|$)/,
     // RM-051: o ensaio instala o tarball com npm --offline e resolve as dependencias pelo cache do npm
     // da estacao; o runner hospedado so tem os tarballs do npm ci, sem os metadados do registro.
     /testar-experiencia-e2e\.cjs(?:\s|$)/,
+    // RM-037: a suite local inteira, com as integracoes locais; o runner hospedado roda o test:ci.
+    /suite-local\.cjs(?:\s|$)/,
 ];
 /**
  * I-38: o runner hospedado nao oferece OrkMind nem a base do tenant. Claim que chama a memoria
@@ -133,7 +139,8 @@ function consultarCi(carregado, sha, remoto = 'origin', executor = executorPadra
     const context = ci.context || 'ork-verify';
     if (!ci.required_for_ship)
         return { schema: 'ork.ci-status/v1', required: false, ok: true, provider: 'github', repository: null, sha, context, state: 'disabled', url: null, detail: 'gate de CI não exigido pelo manifesto' };
-    const remote = (0, util_1.exec)('git', ['remote', 'get-url', remoto], carregado.raiz);
+    // RM-047: o `--remoto` do `ork ci status` vem da linha de comando; so nome de remoto chega ao git.
+    const remote = (0, util_1.exec)('git', ['remote', 'get-url', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ci')], carregado.raiz);
     const repository = remote.ok ? repositorioGitHub(remote.stdout) : null;
     if (!repository)
         return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository: null, sha, context, state: 'unavailable', url: null, detail: `remoto ${remoto} não é um repositório GitHub reconhecível` };

package/dist/claims.js

@@ -58,11 +58,14 @@ exports.anexarComando = anexarComando;
 exports.retirarClaim = retirarClaim;
 exports.carimbarEstado = carimbarEstado;
 exports.tabelaDeClaims = tabelaDeClaims;
+const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const ledger_1 = require("./ledger");
 const manifest_1 = require("./manifest");
 const prova_minima_1 = require("./prova-minima");
 const thread_1 = require("./thread");
+const policies_1 = require("./policies");
+const verify_1 = require("./verify");
 const util_1 = require("./util");
 const claim_lint_1 = require("./claim-lint");
 /** Caminho do `claims.jsonl` da thread (append-only, como o ledger). */
@@ -165,7 +168,42 @@ function adicionarClaim(raiz, threadId, opcoes) {
         estado: claim.estado,
         ...(claim.lint?.length ? { lint: claim.lint.map((a) => a.regra) } : {}),
     });
-    return claim;
+    const avisosDePolicy = opcoes.semProvaLocal ? [] : conferirProvaLocal(raiz, thread, claim, opcoes.executarProva ?? verify_1.executar);
+    return avisosDePolicy.length ? { ...claim, avisosDePolicy } : claim;
+}
+/**
+ * RM-008 (B8): com `claim_sem_prova_local` (ou `claims_failed`) declarada, o registro roda o comando da
+ * claim uma vez, na worktree da thread e no prazo do verify. A claim ja entrou: reprovacao ou estouro
+ * so gravam `policy_warn` no ledger e voltam como aviso. Sem a policy, nada roda.
+ */
+function conferirProvaLocal(raiz, thread, claim, executarProva) {
+    const carregado = (0, manifest_1.carregarManifesto)(raiz);
+    if (!carregado || claim.verificar.length === 0 || !(0, policies_1.policyDeProvaLocal)(carregado.manifesto))
+        return [];
+    const prazoMs = carregado.manifesto.verify.timeout_ms ?? verify_1.TIMEOUT_VERIFY_MS;
+    const cwd = (0, verify_1.cwdDaThread)(raiz, thread);
+    let reprovada;
+    // Suspeitas da revisao de 03/10: sem a worktree (apagada), nada roda e o aviso diz por que, sem culpar a claim.
+    if (!fs.existsSync(cwd))
+        reprovada = { comando: claim.verificar[0], code: -1, estourou: false, semDiretorio: cwd };
+    for (const comando of reprovada ? [] : claim.verificar) {
+        const r = executarProva(`claim ${claim.id}`, comando, cwd, prazoMs);
+        if (!r.ok) {
+            reprovada = { comando, code: r.code, estourou: r.causa === 'timeout' };
+            break;
+        }
+    }
+    if (!reprovada)
+        return [];
+    const violacoes = (0, policies_1.avisos)((0, policies_1.avaliarPolicies)(carregado.manifesto, {
+        gate: 'claims.add', threadId: thread.id, modo: thread.modo, fase: claim.fase ?? undefined,
+        provaLocalReprovada: { claim: claim.id, ...reprovada, prazoMs },
+    }));
+    for (const v of violacoes) {
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread.id), thread.id, ledger_1.TIPOS_DE_EVENTO.politicaAviso, { gate: 'claims.add', claim: claim.id,
+            fase: claim.fase, policy: v.policy, motivo: v.motivo, detalhe: v.detalhe, correcao: v.correcao, modo: thread.modo });
+    }
+    return violacoes;
 }
 /** Prefixo do arquivo das claims de criterio, para o veredito dizer de onde veio. */
 exports.ARQUIVO_DONEWHEN = 'thread.json#doneWhen';

package/dist/company-brain-context.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTEXT_SCHEMA = void 0;
+exports.SERVER_CONTEXT_SCHEMA = exports.CONTEXT_SCHEMA = void 0;
 exports.buildContext = buildContext;
 const portfolio_1 = require("./portfolio");
 const company_brain_client_1 = require("./company-brain-client");
 const company_brain_contract_1 = require("./company-brain-contract");
 const company_brain_source_1 = require("./company-brain-source");
 exports.CONTEXT_SCHEMA = 'ork.brain-context/v1';
+exports.SERVER_CONTEXT_SCHEMA = 'orkmind.company-brain-context/v1';
+const SEM_MODO_CONTEXT = 'brain.selection.context-unsupported';
+const SERVIDOR_INVALIDO = 'brain.context.server-invalid';
 const ID = /^(prod|proj|init)-[a-z0-9][a-z0-9-]{2,47}$/;
 const ORDEM = { prod: 0, proj: 1, init: 2 };
 const LIMITE = 1000;
@@ -27,25 +30,122 @@ function citacaoDe(source) {
         return null;
     return { instance, source_ref, source_hash, source_version, location };
 }
+/** O servidor exige também `authority`: o pacote dele só traz item com a citação inteira; a consulta exige o mesmo. */
+const citadoPeloServidor = (source) => citacaoDe(source) !== null && typeof source.authority === 'string' && source.authority !== '';
 /**
- * Monta o pacote dos ids pedidos mais a cadeia de pais. A fonte canônica é o portfólio local;
- * o Brain é projeção, e a diferença entre os dois sai como frescor e lacuna, nunca é corrigida aqui.
+ * Confere um pacote `orkmind.company-brain-context/v1` contra o lote pedido: schema, tenant, pedido,
+ * digest recalculado, citação inteira, ordem, fecho de pais e destino de cada id pedido.
  */
-function buildContext(c, ids, transport, thread) {
-    const tenant = c.manifesto.memory.tenant;
-    const pedido = [...new Set(ids)].sort(comparar);
-    if (!pedido.length)
-        throw Error('brain.context.ids-required');
-    if (pedido.some(id => !ID.test(id)))
-        throw Error('brain.context.id-invalid');
-    if (pedido.length > LIMITE)
-        throw Error('brain.context.too-many');
-    const fonte = new Map((0, company_brain_source_1.portfolioEntities)((0, portfolio_1.readPortfolio)(c.raiz), { tenant, instance: c.manifesto.project.name, thread, aclRef: 'ork-factory' }).map(e => [e.id, e]));
-    const base = { schema: exports.CONTEXT_SCHEMA, tenant, contrato: company_brain_contract_1.CONTRACT_HASH, thread, pedido };
-    const encerrar = (r) => ({ ...base, state: r.state, ...(r.error ? { error: r.error } : {}), itens: [], lacunas: [], digest: null, consultadoEm: new Date().toISOString() });
+function conferirPacoteDoServidor(r, tenant, lote) {
+    const ctx = r.context;
+    if (!['ok', 'empty'].includes(r.state) || !ctx || typeof ctx !== 'object' || Array.isArray(ctx))
+        return false;
+    if (Object.keys(ctx).sort().join(',') !== 'digest,gaps,items,requested,schema,tenant_id')
+        return false;
+    const { digest: recebido, ...corpo } = ctx;
+    if (ctx.schema !== exports.SERVER_CONTEXT_SCHEMA || ctx.tenant_id !== tenant || (0, company_brain_contract_1.canonical)(ctx.requested) !== (0, company_brain_contract_1.canonical)(lote) ||
+        !Array.isArray(ctx.items) || !Array.isArray(ctx.gaps) || typeof recebido !== 'string' || (0, company_brain_contract_1.digest)(corpo) !== recebido)
+        return false;
+    if (r.state !== (ctx.items.length ? 'ok' : 'empty'))
+        return false;
+    const pedidos = new Set(lote), vistos = new Map(), codigos = new Map();
+    for (const g of ctx.gaps) {
+        if (!g || typeof g.id !== 'string' || typeof g.code !== 'string' || !ID.test(g.id))
+            return false;
+        if (!codigos.has(g.id))
+            codigos.set(g.id, new Set());
+        codigos.get(g.id).add(g.code);
+    }
+    for (const item of ctx.items) {
+        if (!item || typeof item.id !== 'string' || !ID.test(item.id) || vistos.has(item.id))
+            return false;
+        if (item.state === 'withheld') {
+            if (Object.keys(item).length !== 2)
+                return false;
+        }
+        else if (item.state !== 'ok' || !item.entity || typeof item.entity !== 'object' || item.entity.kind !== kindDe(item.id) ||
+            !Number.isInteger(item.entity.version) || !citadoPeloServidor(item.entity.source))
+            return false;
+        vistos.set(item.id, item);
+    }
+    const ordem = ctx.items.map((i) => i.id);
+    const ordenado = [...ordem].sort((a, b) => ORDEM[kindDe(a)] - ORDEM[kindDe(b)] || comparar(a, b));
+    if ((0, company_brain_contract_1.canonical)(ordem) !== (0, company_brain_contract_1.canonical)(ordenado))
+        return false;
+    // Fecho: todo item fora do pedido é pai, um kind acima, de um item citado do pacote.
+    const paisCitados = new Set();
+    for (const item of ctx.items)
+        if (item.state === 'ok') {
+            const parent = item.entity.parent_id;
+            if (typeof parent === 'string' && ID.test(parent) && ORDEM[kindDe(parent)] < ORDEM[kindDe(item.id)])
+                paisCitados.add(parent);
+        }
+    for (const id of vistos.keys())
+        if (!pedidos.has(id) && !paisCitados.has(id))
+            return false;
+    // Destino: todo id pedido sai como item ou como lacuna de desconhecido ou de citação incompleta.
+    for (const id of lote) {
+        const c = codigos.get(id);
+        if (!vistos.has(id) && !(c?.has('entity.unknown') || c?.has('citation.incomplete')))
+            return false;
+        if (vistos.has(id) && (c?.has('entity.unknown') || c?.has('citation.incomplete')))
+            return false;
+    }
+    return true;
+}
+/**
+ * B4.2: resolve o escopo pelo modo `context` do servidor. Devolve null quando o OrkMind não tem o modo
+ * (o chamador usa a consulta), ou a resposta que encerra o pacote.
+ */
+function resolverPeloServidor(transport, tenant, pedido, fonte, pai) {
+    const escopo = new Set(pedido), brain = new Map(), retidos = new Set(), semCitacao = new Set();
+    let primeiro = true;
+    for (let pendentes = pedido; pendentes.length;) {
+        const resolvidosNaVolta = [];
+        for (let inicio = 0; inicio < pendentes.length; inicio += LIMITE) {
+            const lote = pendentes.slice(inicio, inicio + LIMITE);
+            const r = transport({ schema: company_brain_client_1.BRAIN_API, operation: 'query', payload: (0, company_brain_contract_1.validateContract)({ schema: 'orkmind.company-brain-selection/v1',
+                    tenant_id: tenant, facets: { ids: lote, kinds: [], workspace_ids: [], source_instances: [] }, mode: 'context',
+                    limit: lote.length, offset: 0 }) });
+            if (r.state === 'unavailable' && r.error === SEM_MODO_CONTEXT)
+                return primeiro ? null : { state: 'conflict', error: SERVIDOR_INVALIDO };
+            primeiro = false;
+            if (falha(r.state))
+                return r;
+            if (!conferirPacoteDoServidor(r, tenant, lote))
+                return { state: 'conflict', error: SERVIDOR_INVALIDO };
+            const ctx = r.context;
+            for (const g of ctx.gaps)
+                if (g.code === 'citation.incomplete')
+                    semCitacao.add(g.id);
+            for (const item of ctx.items) {
+                // Pai que outro lote ou volta já resolveu vale uma vez só: a primeira resposta fica.
+                if (escopo.has(item.id) && !lote.includes(item.id))
+                    continue;
+                escopo.add(item.id);
+                resolvidosNaVolta.push(item.id);
+                if (item.state === 'withheld')
+                    retidos.add(item.id);
+                else
+                    brain.set(item.id, { ...item.entity, id: item.id });
+            }
+            resolvidosNaVolta.push(...lote);
+        }
+        // O servidor fecha os pais que o Brain conhece; os que só a fonte local conhece vão na próxima volta.
+        const novos = new Set();
+        for (const id of resolvidosNaVolta)
+            if (!retidos.has(id))
+                for (const parent of [pai(id, fonte.get(id)?.parent_id), pai(id, brain.get(id)?.parent_id)])
+                    if (parent && !escopo.has(parent))
+                        novos.add(parent);
+        novos.forEach(id => escopo.add(id));
+        pendentes = [...novos].sort(comparar);
+    }
+    return { brain, retidos, semCitacao, escopo };
+}
+/** B4.1: o caminho anterior ao modo `context`, por `query` e `get`, para um OrkMind sem o modo. */
+function resolverPelaConsulta(transport, tenant, pedido, fonte, pai) {
     const escopo = new Set(pedido), brain = new Map(), retidos = new Set();
-    // O pai só entra por um filho visível e tem kind acima dele: init, proj e prod fecham em três voltas.
-    const pai = (id, parent) => typeof parent === 'string' && ID.test(parent) && ORDEM[kindDe(parent)] < ORDEM[kindDe(id)] ? parent : null;
     let gets = 0;
     for (let pendentes = pedido; pendentes.length;) {
         for (let inicio = 0; inicio < pendentes.length; inicio += LIMITE) {
@@ -54,7 +154,7 @@ function buildContext(c, ids, transport, thread) {
                     tenant_id: tenant, facets: { ids: lote, kinds: [], workspace_ids: [], source_instances: [] }, mode: 'selection',
                     limit: lote.length, offset: 0 }) });
             if (falha(r.state))
-                return encerrar(r);
+                return r;
             const itens = Array.isArray(r.items) ? r.items : [];
             for (const item of itens)
                 if (item?.state === 'ok' && doLote.has(item.entity?.id))
@@ -67,10 +167,10 @@ function buildContext(c, ids, transport, thread) {
             else if (retidosNoLote)
                 for (const id of faltantes) {
                     if (++gets > LIMITE_DE_GET)
-                        return encerrar({ state: 'unavailable', error: 'brain.context.get-limit' });
+                        return { state: 'unavailable', error: 'brain.context.get-limit' };
                     const g = transport({ schema: company_brain_client_1.BRAIN_API, operation: 'get', payload: { tenant_id: tenant, id } });
                     if (falha(g.state))
-                        return encerrar(g);
+                        return g;
                     if (g.state === 'withheld')
                         retidos.add(id);
                     else if (g.state === 'ok' && g.entity?.id === id)
@@ -87,6 +187,35 @@ function buildContext(c, ids, transport, thread) {
                     }
         pendentes = novos.sort(comparar);
     }
+    return { brain, retidos, semCitacao: new Set(), escopo };
+}
+/**
+ * Monta o pacote dos ids pedidos mais a cadeia de pais. A fonte canônica é o portfólio local;
+ * o Brain é projeção, e a diferença entre os dois sai como frescor e lacuna, nunca é corrigida aqui.
+ */
+function buildContext(c, ids, transport, thread) {
+    const tenant = c.manifesto.memory.tenant;
+    const pedido = [...new Set(ids)].sort(comparar);
+    if (!pedido.length)
+        throw Error('brain.context.ids-required');
+    if (pedido.some(id => !ID.test(id)))
+        throw Error('brain.context.id-invalid');
+    if (pedido.length > LIMITE)
+        throw Error('brain.context.too-many');
+    const fonte = new Map((0, company_brain_source_1.portfolioEntities)((0, portfolio_1.readPortfolio)(c.raiz), { tenant, instance: c.manifesto.project.name, thread, aclRef: 'ork-factory' }).map(e => [e.id, e]));
+    const base = { schema: exports.CONTEXT_SCHEMA, tenant, contrato: company_brain_contract_1.CONTRACT_HASH, thread, pedido };
+    // O pai só entra por um filho visível e tem kind acima dele: init, proj e prod fecham em três voltas.
+    const pai = (id, parent) => typeof parent === 'string' && ID.test(parent) && ORDEM[kindDe(parent)] < ORDEM[kindDe(id)] ? parent : null;
+    const doServidor = resolverPeloServidor(transport, tenant, pedido, fonte, pai);
+    const caminho = doServidor === null ? 'consulta' : 'servidor';
+    const encerrar = (r) => ({ ...base, state: r.state, ...(r.error ? { error: r.error } : {}), itens: [], lacunas: [],
+        digest: null, consultadoEm: new Date().toISOString(), caminho });
+    if (doServidor && 'state' in doServidor)
+        return encerrar(doServidor);
+    const resolvido = doServidor ?? resolverPelaConsulta(transport, tenant, pedido, fonte, pai);
+    if ('state' in resolvido)
+        return encerrar(resolvido);
+    const { escopo, brain, retidos, semCitacao } = resolvido;
     const itens = [], lacunas = [];
     const lacuna = (id, codigo) => lacunas.push({ id, codigo });
     for (const id of escopo) {
@@ -95,12 +224,19 @@ function buildContext(c, ids, transport, thread) {
             lacuna(id, 'brain.retido');
             continue;
         }
+        // Sem citação no Brain vale como no caminho da consulta: o Brain tem a entidade, mas ela não é citável.
+        if (semCitacao.has(id)) {
+            lacuna(id, 'citacao.incompleta');
+            continue;
+        }
         const b = brain.get(id), f = fonte.get(id);
         if (!b && !f) {
             lacuna(id, 'entidade.desconhecida');
             continue;
         }
-        const entidade = b ?? f, citacao = citacaoDe(entidade.source);
+        // Suspeitas da revisao de 03/10: a citacao exige `authority` nos dois caminhos, como o servidor (o
+        // schema do Source a exige); sem isso, um Brain fora do contrato dava pacote e digest diferentes por caminho.
+        const entidade = b ?? f, citacao = citadoPeloServidor(entidade.source) ? citacaoDe(entidade.source) : null;
         if (!citacao) {
             lacuna(id, 'citacao.incompleta');
             continue;
@@ -128,5 +264,5 @@ function buildContext(c, ids, transport, thread) {
     lacunas.sort((a, b) => comparar(a.id, b.id) || comparar(a.codigo, b.codigo));
     // O digest cobre o que foi dito e de onde veio; o horário da consulta fica fora para o pacote ser reproduzível.
     const corpo = { ...base, state: (itens.length ? 'ok' : 'empty'), itens, lacunas };
-    return { ...corpo, digest: (0, company_brain_contract_1.digest)(corpo), consultadoEm: new Date().toISOString() };
+    return { ...corpo, digest: (0, company_brain_contract_1.digest)(corpo), consultadoEm: new Date().toISOString(), caminho };
 }

package/dist/docs.js

@@ -43,6 +43,7 @@ exports.comandosDaAjuda = comandosDaAjuda;
 exports.verificarDocs = verificarDocs;
 exports.renderizarRelance = renderizarRelance;
 exports.renderizarEstado = renderizarEstado;
+exports.docsPendentesDoMerge = docsPendentesDoMerge;
 exports.textoDaVerificacao = textoDaVerificacao;
 exports.escreverYaml = escreverYaml;
 exports.mergeDaThread = mergeDaThread;
@@ -576,20 +577,58 @@ function verificarEstadoDoRoadmap(raiz, d, base, achados) {
  * mesmo `ship(<thread>)` do `sincronizarDocs`: tudo o que ela acusa o `sincronizar` corrige.
  */
 function verificarMergeDaThread(raiz, d, base, achados, pr = false) {
-    const sdlc = ehMapa(d.dados.sdlc) ? d.dados.sdlc : null;
-    const thread = sdlc && typeof sdlc.thread === 'string' ? sdlc.thread.trim() : '';
-    if (!thread)
-        return;
-    const merges = mergesDaThreadNoGit(raiz, thread, base);
-    if (merges.length === 0)
-        return;
-    const codigo = String((ehMapa(d.dados.estado) ? d.dados.estado.codigo : null) ?? '');
-    if (codigo === 'Mesclado')
+    const pendente = pendenciaDeMerge(raiz, d, base);
+    if (!pendente)
         return;
+    const { thread, merges, codigo } = pendente;
     achados.push((pr ? aviso : erro)(d.arquivo, d.id, 'docs.paridade.merge', `a thread ${thread} entrou na ${base} pelo merge ${merges[0].slice(0, 7)} (ship(${thread})), e o estado.codigo diz "${codigo || 'vazio'}"` +
         (pr ? ' (no PR, aviso: o push da main reprova)' : ''), `abra um PR de docs sobre a ${base} atualizada com ork docs sincronizar --escrever --so ${d.id} (o item e os índices); ` +
         `se o item tem outra fatia em curso, aponte sdlc.thread para a thread dela`));
 }
+/**
+ * A regra do `docs.paridade.merge`, isolada para o `ork ship registrar-pr` (RM-044, A3): a pagina cujo
+ * `sdlc.thread` ja tem merge `ship(<thread>)` na base e cujo `estado.codigo` ainda nao diz `Mesclado`.
+ * `thread`, quando dada, restringe a pagina a essa thread.
+ */
+function pendenciaDeMerge(raiz, d, base, thread) {
+    const sdlc = ehMapa(d.dados.sdlc) ? d.dados.sdlc : null;
+    const daPagina = sdlc && typeof sdlc.thread === 'string' ? sdlc.thread.trim() : '';
+    if (!daPagina || (thread !== undefined && daPagina !== thread))
+        return null;
+    const codigo = String((ehMapa(d.dados.estado) ? d.dados.estado.codigo : null) ?? '');
+    if (codigo === 'Mesclado')
+        return null;
+    const merges = mergesDaThreadNoGit(raiz, daPagina, base);
+    if (merges.length === 0)
+        return null;
+    return { thread: daPagina, merges, codigo };
+}
+/**
+ * RM-044 (A3): as paginas do roadmap, lidas da `ref` (a base remota depois do fetch, nao a copia local,
+ * que pode estar atras), que a regra `docs.paridade.merge` vai acusar por causa da `thread`. Nao grava
+ * nada: so lista. Ref ilegivel ou sem `docs/roadmap` devolve lista vazia.
+ */
+function docsPendentesDoMerge(raiz, thread, ref) {
+    const ls = git(raiz, ['ls-tree', '--name-only', `${ref}:${exports.DIR_ROADMAP}`]);
+    if (!ls.ok || !ls.saida)
+        return [];
+    const pendentes = [];
+    for (const nome of ls.saida.split('\n').filter(ehPaginaDeDocs).sort()) {
+        const arquivo = `${exports.DIR_ROADMAP}/${nome}`;
+        const blob = git(raiz, ['show', `${ref}:${arquivo}`]);
+        if (!blob.ok)
+            continue;
+        const lido = documentoDeTexto(arquivo, `${blob.saida}\n`);
+        if (!('doc' in lido) || lido.doc.tipo !== 'roadmap')
+            continue;
+        const p = pendenciaDeMerge(raiz, lido.doc, ref, thread);
+        if (!p)
+            continue;
+        pendentes.push({ id: lido.doc.id, arquivo, codigo: p.codigo, merge: p.merges[0],
+            comando: `ork docs sincronizar --escrever --so ${lido.doc.id}` });
+    }
+    return pendentes;
+}
 /** Os indices gerados (`docs/roadmap/README.md`, `docs/produto/README.md`) e o que o frontmatter diz. */
 const INDICES_GERADOS = [
     [`${exports.DIR_ROADMAP}/README.md`, (docs) => tabelaDoRoadmap(docs)],