@orkastery/cli 0.5.3 → 0.6.0

package/dist/maestro-runtime.js

@@ -51,6 +51,7 @@ const ledger_1 = require("./ledger");
 const horario_1 = require("./horario");
 const conducao_1 = require("./conducao");
 const conducao_texto_1 = require("./conducao-texto");
+const indice_1 = require("./indice");
 /** Valida todos os campos consumidos antes de deduplicar, filtrar ou publicar a fila. */
 const retryView = zod_1.z.object({
     id: zod_1.z.string().max(160).regex(/^R[1-9]\d*$/),
@@ -163,16 +164,34 @@ function operationalSources(reader, threads, native = [], now = new Date().toISO
                 sections.ship.items.push((0, maestro_sources_1.item)(`ship:${t.id}`, 'Entrega', proven ? 'delivered' : 'incomplete', refs, { pushVerified: proven, mergeSha: done?.mergeSha ?? null, receiptAt: ship.data.ts, receiptAtLocal: local(ship.data.ts) }));
             }
         }
+        // RM-059 (T8.2a, D2 da thread ork-rm059ritual): o que o Ritual do MASTER le para saber quais entregas esperam a nota
+        // do dono e mostrar a prova: o regime e as classes do MASTER log, o indice derivado dos eventos ja lidos (sem git),
+        // as reprovacoes tipadas e a entrega. Os eventos de ensaio ja ficaram de fora acima; recibo de ship invalido (GO-FIX7)
+        // tambem nao entra, nem na entrega nem no indice.
+        const validos = events.filter(e => !['ship_done', 'ship_started', 'ship_blocked'].includes(e.tipo) || shipView.safeParse(e).success);
+        const entrega = validos.filter(e => e.tipo === 'ship_done').at(-1);
+        // A entrega por artefato (`artifact_delivered`, a thread so de planejamento) tambem espera a nota: sem `ship_done`,
+        // vale o ultimo artefato, sem merge. O retrato nao confere o arquivo; o nucleo confere ao gravar a nota.
+        const artefato = entrega ? undefined : events.filter(e => e.tipo === 'artifact_delivered' && typeof e.arquivo === 'string').at(-1);
+        const quando = (entrega ?? artefato)?.ts;
+        const deliveredAt = typeof quando === 'string' && Number.isFinite(Date.parse(quando)) ? quando : null;
+        const indice = (0, indice_1.calcularIndice)(validos);
+        const daEntrega = { index: indice.valor, indexDetail: (0, maestro_sources_1.safeText)(indice.parcelas.map(x => `${x.evento} x${x.ocorrencias}`).join(', ')),
+            reprovals: events.filter(e => e.tipo === 'gate_blocked').length, deliveredAt, deliveredAtLocal: deliveredAt ? local(deliveredAt) : null,
+            deliveredSha: typeof entrega?.mergeSha === 'string' && /^[a-f0-9]{40}$/.test(entrega.mergeSha) ? entrega.mergeSha : null,
+            ...(artefato ? { deliveredArtifact: (0, maestro_sources_1.safeText)(String(artefato.arquivo)) } : {}) };
         try {
             const receipt = reader.json(`.orkastery/threads/${t.id}/master-log.json`);
             if (receipt) {
                 const pending = receipt.contrato === master_1.CONTRATO_MASTER_PENDENTE;
                 if ((pending ? (0, master_1.validarMasterPendente)(receipt) : (0, master_1.validarMasterLog)(receipt)).length || receipt.thread !== t.id)
                     throw Error('invalid');
-                sections.master.items.push((0, maestro_sources_1.item)(`master:${t.id}`, pending ? 'Ratificação humana pendente' : 'MASTER', pending ? 'ratificacao-pendente' : 'recorded', refs, { score: pending ? null : typeof receipt.score === 'number' ? receipt.score : null }));
+                const classes = Array.isArray(receipt.classesDeFalha) ? (0, maestro_sources_1.safeText)(receipt.classesDeFalha.filter(c => typeof c === 'string').join(', ')) : null;
+                sections.master.items.push((0, maestro_sources_1.item)(`master:${t.id}`, pending ? 'Ratificação humana pendente' : 'MASTER', pending ? 'ratificacao-pendente' : 'recorded', refs, { score: pending ? null : typeof receipt.score === 'number' ? receipt.score : null,
+                    regime: !pending && typeof receipt.regime === 'string' ? (0, maestro_sources_1.safeText)(receipt.regime) : null, classes, ...daEntrega }));
             }
-            else if (lastShip || t.faseAtual === 'MASTER')
-                sections.master.items.push((0, maestro_sources_1.item)(`master:${t.id}`, 'Score humano pendente', 'pending', refs, { score: null }));
+            else if (lastShip || artefato || t.faseAtual === 'MASTER')
+                sections.master.items.push((0, maestro_sources_1.item)(`master:${t.id}`, 'Score humano pendente', 'pending', refs, { score: null, regime: null, classes: null, ...daEntrega }));
         }
         catch {
             sections.master.gaps.push(`master.invalid:${t.id}`);

package/dist/manifest.js

@@ -37,7 +37,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EMBEDDING_PADRAO = exports.LIMITE_MANIFESTO_BYTES = exports.DIR_ESTADO = exports.NOME_MANIFESTO_LEGADO = exports.NOME_MANIFESTO = void 0;
+exports.EMBEDDING_PADRAO = exports.TETO_MAXIMO_DE_CUSTO_USD = exports.TETO_MAXIMO_DE_TEAMMATES = exports.LIMITE_MANIFESTO_BYTES = exports.DIR_ESTADO = exports.NOME_MANIFESTO_LEGADO = exports.NOME_MANIFESTO = void 0;
 exports.fixarDiretorioDoProjeto = fixarDiretorioDoProjeto;
 exports.diretorioDoProjeto = diretorioDoProjeto;
 exports.acharRaiz = acharRaiz;
@@ -45,6 +45,8 @@ exports.dirEstado = dirEstado;
 exports.validarOptInPlaybook = validarOptInPlaybook;
 exports.configDeEmbedding = configDeEmbedding;
 exports.carregarManifesto = carregarManifesto;
+exports.cliDaMemoriaValido = cliDaMemoriaValido;
+exports.comandosDoTextoDoManifesto = comandosDoTextoDoManifesto;
 exports.exigirManifesto = exigirManifesto;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -59,6 +61,11 @@ const horario_1 = require("./horario");
 const experiencia_1 = require("./experiencia");
 const runtime_ambiente_1 = require("./runtime-ambiente");
 const orkmind_1 = require("./orkmind");
+const dsn_da_memoria_1 = require("./dsn-da-memoria");
+const locale_1 = require("./locale");
+const contrato_1 = require("./forja/contrato");
+const branch_de_estado_1 = require("./branch-de-estado");
+const check_modo_1 = require("./check-modo");
 exports.NOME_MANIFESTO = 'orkastery.yaml';
 exports.NOME_MANIFESTO_LEGADO = 'devmaster.yaml';
 exports.DIR_ESTADO = '.orkastery';
@@ -91,7 +98,12 @@ function acharRaiz(dirInicial = diretorioDoProjeto()) {
 }
 /** Caminho do diretorio de estado da raiz informada. */
 function dirEstado(raiz) {
-    return path.join(raiz, exports.DIR_ESTADO);
+    // RM-047 (fronteira de confiança): `.orkastery` versionado como link levaria o estado para fora da raiz.
+    const dir = path.join(raiz, exports.DIR_ESTADO);
+    if (fs.lstatSync(dir, { throwIfNoEntry: false })?.isSymbolicLink()) {
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.dirEstadoLink(exports.DIR_ESTADO));
+    }
+    return dir;
 }
 function texto(v, padrao) {
     return typeof v === 'string' ? v : typeof v === 'number' ? String(v) : padrao;
@@ -99,6 +111,15 @@ function texto(v, padrao) {
 function numero(v, padrao) {
     return typeof v === 'number' ? v : typeof v === 'string' && v.trim() !== '' && !isNaN(Number(v)) ? Number(v) : padrao;
 }
+/**
+ * RM-058 N2: as vagas da fila pesada, inteiras de 0 a 64. So o 0 escrito desliga a fila; fracao positiva sobe para 1 e
+ * valor sem sentido volta ao padrao 1, nunca a "sem fila".
+ */
+function vagasPesadas(v) {
+    if (!Number.isFinite(v) || v < 0)
+        return 1;
+    return v === 0 ? 0 : Math.min(64, Math.max(1, Math.trunc(v)));
+}
 /**
  * I-37 (D2): `verify.timeout_ms` e `verify.timeout_ms_por_comando`. Prazo so vale inteiro
  * positivo em milissegundos, entre 1 s e 24 h; o resto e erro do manifesto, porque um prazo
@@ -122,8 +143,8 @@ function prazosDoVerify(verify, erros) {
     const brutos = mapa(verify.timeout_ms_por_comando);
     const porComando = {};
     for (const nome of Object.keys(brutos)) {
-        if (!['build', 'test', 'typecheck'].includes(nome)) {
-            erros.push(`verify.timeout_ms_por_comando.${nome}: so build, test e typecheck tem prazo proprio`);
+        if (!['build', 'test', 'typecheck', 'security_scan'].includes(nome)) {
+            erros.push(`verify.timeout_ms_por_comando.${nome}: so build, test, typecheck e security_scan tem prazo proprio`);
             continue;
         }
         const n = prazo(`verify.timeout_ms_por_comando.${nome}`, brutos[nome]);
@@ -135,8 +156,26 @@ function prazosDoVerify(verify, erros) {
     return saida;
 }
 /**
- * RM-037 (rm037defeito, defeito 5): `ci.external_repositories`, mapa `dono/nome` para o check exigido no
- * head do PR (texto vazio ou nulo: repositorio sem CI). Forma invalida e erro do manifesto, nunca adivinhada.
+ * RM-037 (defeitos de 19 e 20/10/2026, defeito 2): `worktree.dependencias`, o comando que o `ork` roda dentro de toda
+ * worktree nova da thread. So vale texto: outro tipo e erro do manifesto, porque um preparo mal escrito que sumisse em
+ * silencio deixaria a worktree nova sem as dependencias, como antes. Texto vazio e o mesmo que nenhum.
+ */
+function dependenciasDaWorktree(v, erros) {
+    if (v === undefined || v === null)
+        return {};
+    if (typeof v !== 'string') {
+        erros.push(`worktree.dependencias precisa ser o comando, em texto (recebido ${exibir(v)})`);
+        return {};
+    }
+    const comando = v.trim();
+    return comando ? { dependencias: comando } : {};
+}
+/** O caminho de um projeto: dois segmentos ou mais (os subgrupos do GitLab). */
+const CAMINHO_DE_PROJETO = /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+$/;
+/**
+ * RM-037 (rm037defeito, defeito 5): `ci.external_repositories`, mapa do caminho do projeto (`dono/nome` no GitHub,
+ * `grupo/sub/projeto` no GitLab) para o check exigido no head do PR (texto vazio ou nulo: repositorio sem CI). Forma
+ * invalida e erro do manifesto, nunca adivinhada.
  */
 function repositoriosExternos(v, erros) {
     if (v === undefined || v === null)
@@ -147,8 +186,8 @@ function repositoriosExternos(v, erros) {
     }
     const r = {};
     for (const [repo, check] of Object.entries(v)) {
-        if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo)) {
-            erros.push(`ci.external_repositories: "${repo}" nao e dono/nome do GitHub`);
+        if (!CAMINHO_DE_PROJETO.test(repo) || repo.split('/').some((p) => p === '.' || p === '..')) {
+            erros.push(`ci.external_repositories: "${repo}" nao e dono/nome do GitHub nem grupo/subgrupo/projeto do GitLab`);
             continue;
         }
         if (check !== null && typeof check !== 'string') {
@@ -187,6 +226,292 @@ function lerGrafo(v, avisos) {
     avisos.push(`grafo.mcp deve ser true ou false; vale false (${mostrar(mcp)} nao reconhecido)`);
     return { mcp: false };
 }
+/**
+ * RM-072 (D1 da ork-check5x): o bloco `check`. `mode` aceita `agile` e `classic` (sem diferenca de caixa); outro valor e
+ * erro do manifesto com os dois valores aceitos, porque um modo mal escrito que caisse no padrao em silencio mudaria o
+ * CHECK sem ninguem saber. Ausente, `mode` vale o padrao na hora da rodada. Chave desconhecida so avisa.
+ */
+function lerCheck(v, erros, avisos) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        erros.push(`check precisa ser um mapa com mode: ${check_modo_1.MODOS_DO_CHECK.join(' ou ')} (recebido ${exibir(v)})`);
+        return undefined;
+    }
+    for (const chave of Object.keys(v)) {
+        if (!['mode', 'agile'].includes(chave))
+            avisos.push(`check.${chave} desconhecida; o bloco check tem mode e agile`);
+    }
+    const check = {};
+    if (v.mode !== undefined && v.mode !== null) {
+        const modo = (0, check_modo_1.lerModo)(v.mode);
+        if (modo)
+            check.mode = modo;
+        else
+            erros.push(`check.mode invalido: ${exibir(v.mode)} (aceitos: ${check_modo_1.MODOS_DO_CHECK.join(', ')})`);
+    }
+    const agile = lerAgile(v.agile, erros, avisos);
+    if (agile)
+        check.agile = agile;
+    return check;
+}
+/** Nome de lane: o que vira `test:<lane>` no ledger. */
+const NOME_DE_LANE = /^[a-z0-9][a-z0-9-]{0,31}$/;
+/**
+ * RM-072 (D3): o bloco `check.agile`. Cada chave liga uma peca do Agile; tipo errado e erro do manifesto, porque uma
+ * peca mal escrita que sumisse em silencio mudaria o que o CHECK roda. `produto` so aceita caminho relativo dentro da
+ * raiz, fora do estado do `ork` e do `.git` (o hash da guarda le esses arquivos).
+ */
+function lerAgile(v, erros, avisos) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        erros.push(`check.agile precisa ser um mapa (recebido ${exibir(v)})`);
+        return undefined;
+    }
+    const conhecidas = ['produto', 'preparo', 'test', 'apos_a_varredura', 'osv_scanner', 'oxlint'];
+    for (const chave of Object.keys(v)) {
+        if (!conhecidas.includes(chave))
+            avisos.push(`check.agile.${chave} desconhecida; o bloco check.agile tem ${conhecidas.join(', ')}`);
+    }
+    const agile = {};
+    if (v.produto !== undefined && v.produto !== null) {
+        const lista = Array.isArray(v.produto) ? v.produto : [v.produto];
+        const validos = [];
+        for (const item of lista) {
+            const caminho = typeof item === 'string' ? item.trim().replace(/\/+$/, '') : '';
+            const normal = caminho ? path.posix.normalize(caminho) : '';
+            if (!caminho || path.isAbsolute(caminho) || normal.startsWith('..') || /^(\.orkastery|\.git)(\/|$)/.test(normal)) {
+                erros.push(`check.agile.produto: ${exibir(item)} precisa ser um caminho relativo dentro da raiz, fora de .orkastery e .git`);
+            }
+            else
+                validos.push(normal);
+        }
+        if (validos.length)
+            agile.produto = validos;
+    }
+    if (v.preparo !== undefined && v.preparo !== null) {
+        if (typeof v.preparo === 'string' && v.preparo.trim())
+            agile.preparo = v.preparo.trim();
+        else
+            erros.push(`check.agile.preparo precisa ser o comando, em texto (recebido ${exibir(v.preparo)})`);
+    }
+    if (v.test !== undefined && v.test !== null) {
+        if (typeof v.test !== 'object' || Array.isArray(v.test)) {
+            erros.push(`check.agile.test precisa ser um mapa de lane para comando (recebido ${exibir(v.test)})`);
+        }
+        else {
+            const lanes = {};
+            for (const [lane, comando] of Object.entries(v.test)) {
+                if (!NOME_DE_LANE.test(lane))
+                    erros.push(`check.agile.test.${lane}: nome de lane aceita [a-z0-9-], ate 32 caracteres`);
+                else if (typeof comando !== 'string' || !comando.trim())
+                    erros.push(`check.agile.test.${lane} precisa ser o comando, em texto`);
+                else
+                    lanes[lane] = comando.trim();
+            }
+            if (Object.keys(lanes).length)
+                agile.test = lanes;
+        }
+    }
+    if (v.apos_a_varredura !== undefined && v.apos_a_varredura !== null) {
+        const validas = [];
+        for (const item of Array.isArray(v.apos_a_varredura) ? v.apos_a_varredura : [v.apos_a_varredura]) {
+            if (typeof item === 'string' && agile.test && Object.hasOwn(agile.test, item))
+                validas.push(item);
+            else
+                erros.push(`check.agile.apos_a_varredura: ${exibir(item)} precisa ser uma lane de check.agile.test`);
+        }
+        if (validas.length)
+            agile.apos_a_varredura = validas;
+    }
+    for (const chave of ['osv_scanner', 'oxlint']) {
+        const valor = v[chave];
+        if (valor === undefined || valor === null)
+            continue;
+        if (typeof valor === 'boolean')
+            agile[chave] = valor;
+        else
+            erros.push(`check.agile.${chave} precisa ser true ou false (recebido ${exibir(valor)})`);
+    }
+    return agile;
+}
+/** RM-059 (T10.4): os limites dos tetos de agent teams, os mesmos que o Portao de Tarefas aceita do ambiente. */
+exports.TETO_MAXIMO_DE_TEAMMATES = 8;
+exports.TETO_MAXIMO_DE_CUSTO_USD = 500;
+/**
+ * RM-059 (T10.4, D11 da thread ork-rm059portao): agent teams no despacho do GO, so em piloto. `runtime.agent_teams`
+ * liga com `ligado: true` e os dois tetos validos: `teammates` inteiro de 1 a 8 e `custo_usd` maior que 0 e ate 500,
+ * escrito como numero decimal simples. Ausente ou `ligado: false` fica desligado sem aviso; ligado com teto invalido,
+ * outro tipo ou chave desconhecida avisa e fica desligado, nunca erro: a chave e experimental e nao para a fabrica.
+ */
+function lerAgentTeams(v, avisos) {
+    const mostrar = (x) => (x === undefined ? 'ausente' : JSON.stringify(x).slice(0, 80));
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        avisos.push(`runtime.agent_teams deve ser um mapa com ligado, teammates e custo_usd; fica desligado (${mostrar(v)} nao reconhecido)`);
+        return undefined;
+    }
+    for (const chave of Object.keys(v)) {
+        if (!['ligado', 'teammates', 'custo_usd'].includes(chave))
+            avisos.push(`runtime.agent_teams.${chave} desconhecida; o bloco so tem ligado, teammates e custo_usd`);
+    }
+    if (v.ligado !== true) {
+        if (v.ligado !== undefined && v.ligado !== null && v.ligado !== false) {
+            avisos.push(`runtime.agent_teams.ligado deve ser true ou false; fica desligado (${mostrar(v.ligado)} nao reconhecido)`);
+        }
+        return undefined;
+    }
+    const teammates = v.teammates;
+    const custo = v.custo_usd;
+    const tetoOk = typeof teammates === 'number' && Number.isInteger(teammates) && teammates >= 1 && teammates <= exports.TETO_MAXIMO_DE_TEAMMATES;
+    const custoOk = typeof custo === 'number' && /^\d+(?:\.\d+)?$/.test(String(custo)) && custo > 0 && custo <= exports.TETO_MAXIMO_DE_CUSTO_USD;
+    if (!tetoOk || !custoOk) {
+        avisos.push(`runtime.agent_teams ligado sem teto valido (teammates inteiro de 1 a ${exports.TETO_MAXIMO_DE_TEAMMATES} e custo_usd maior que 0 ` +
+            `e ate ${exports.TETO_MAXIMO_DE_CUSTO_USD}; recebido teammates ${mostrar(teammates)} e custo_usd ${mostrar(custo)}); fica desligado`);
+        return undefined;
+    }
+    return { teammates: teammates, custo_usd: custo };
+}
+/**
+ * RM-026 K7 (D1): `conhecimento.dir`, a pasta dos documentos `ork.conhecimento/v1`. Sem o bloco, o projeto nao
+ * declarou conhecimento. Bloco que nao e mapa e `dir` vazio avisam e ficam declarados com `dir` vazio, que o
+ * leitor (`conhecimento.ts`) recusa com `conhecimento.dir-invalido`: quem declarou nao ouve que nao declarou.
+ * Chave desconhecida so avisa. Ler a pasta nao executa nada, e a regra do caminho mora no leitor.
+ */
+function lerBlocoConhecimento(v, avisos) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        avisos.push('conhecimento deve ser um mapa com dir: <pasta dentro da raiz>; o leitor recusa ate corrigir');
+        return { dir: '' };
+    }
+    for (const chave of Object.keys(v))
+        if (chave !== 'dir')
+            avisos.push(`conhecimento.${chave} desconhecida; o bloco conhecimento so tem dir`);
+    const dir = texto(v.dir, '').trim();
+    if (!dir)
+        avisos.push('conhecimento.dir deve ser uma pasta dentro da raiz, como docs/conhecimento; o leitor recusa ate corrigir');
+    return { dir };
+}
+/** Nome de host sem esquema, porta, caminho ou credencial; um rotulo so vale (`localhost`). */
+const HOST_DA_FORJA = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*$/;
+const CHAVES_DA_FORJA = ['tipo', 'host', 'porta', 'caminho_base', 'ssh_host', 'ssh_porta', 'ca'];
+/**
+ * O bloco opcional `forja:`. Ausente, nada muda: tudo vem do remoto e da sondagem. Valor fora da forma e erro do
+ * manifesto, nunca adivinhado: um host ou uma porta errados mandariam a consulta, e o login da CLI, a outro servidor.
+ * Chave desconhecida so avisa. `caminho_base` `/` e o mesmo que nenhum subcaminho.
+ */
+function lerBlocoForja(v, erros, avisos) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        erros.push(`forja deve ser um mapa com ${CHAVES_DA_FORJA.join(', ')} (recebido ${exibir(v)})`);
+        return undefined;
+    }
+    for (const chave of Object.keys(v)) {
+        if (!CHAVES_DA_FORJA.includes(chave))
+            avisos.push(`forja.${chave} desconhecida; o bloco forja tem ${CHAVES_DA_FORJA.join(', ')}`);
+    }
+    const forja = {};
+    if (v.tipo !== undefined && v.tipo !== null) {
+        if (typeof v.tipo === 'string' && contrato_1.TIPOS_DE_FORJA.includes(v.tipo))
+            forja.tipo = v.tipo;
+        else
+            erros.push(`forja.tipo aceita ${contrato_1.TIPOS_DE_FORJA.join(' ou ')} (recebido ${exibir(v.tipo)})`);
+    }
+    for (const chave of ['host', 'ssh_host']) {
+        const x = v[chave];
+        if (x === undefined || x === null)
+            continue;
+        const t = typeof x === 'string' ? x.trim().toLowerCase() : '';
+        if (HOST_DA_FORJA.test(t))
+            forja[chave] = t;
+        else
+            erros.push(`forja.${chave} deve ser um nome de host sem esquema, porta ou caminho (recebido ${exibir(x)})`);
+    }
+    for (const chave of ['porta', 'ssh_porta']) {
+        const x = v[chave];
+        if (x === undefined || x === null)
+            continue;
+        if (typeof x === 'number' && Number.isInteger(x) && x >= 1 && x <= 65535)
+            forja[chave] = x;
+        else
+            erros.push(`forja.${chave} deve ser um inteiro de 1 a 65535 (recebido ${exibir(x)})`);
+    }
+    if (v.caminho_base !== undefined && v.caminho_base !== null) {
+        const t = typeof v.caminho_base === 'string' ? v.caminho_base.trim().replace(/\/+$/, '') : null;
+        const valido = t !== null && (t === '' || (/^(?:\/[A-Za-z0-9._~-]+)+$/.test(t) && !t.split('/').some((p) => p === '.' || p === '..')));
+        if (!valido)
+            erros.push(`forja.caminho_base deve ser um caminho absoluto como /gitlab, sem .. (recebido ${exibir(v.caminho_base)})`);
+        else if (t)
+            forja.caminho_base = t;
+    }
+    if (forja.caminho_base && forja.tipo === 'github') {
+        erros.push('forja.caminho_base só vale para forja servida em subcaminho (gitlab); o GitHub não tem');
+    }
+    if (v.ca !== undefined && v.ca !== null) {
+        if (typeof v.ca === 'string' && path.isAbsolute(v.ca) && path.normalize(v.ca) === v.ca)
+            forja.ca = v.ca;
+        else
+            erros.push(`forja.ca deve ser o caminho absoluto de um arquivo PEM (recebido ${exibir(v.ca)})`);
+    }
+    return forja;
+}
+/** Um produtor: o slug de um app ou de um job, ou `status:<login>`. */
+const PRODUTOR = /^(?:status:)?[A-Za-z0-9][A-Za-z0-9_.-]{0,99}$/;
+/**
+ * `ci.produtor`: quem pode publicar o check exigido. Ausente: o padrao da forja. Lista vazia e erro (o gate nunca
+ * ficaria verde), e entrada que nao e produtor tambem: nunca se adivinha quem aprova.
+ */
+function lerProdutores(v, erros) {
+    if (v === undefined || v === null)
+        return undefined;
+    const lista = typeof v === 'string' ? [v] : Array.isArray(v) ? v : null;
+    if (!lista || lista.length === 0 || lista.length > 20) {
+        erros.push('ci.produtor deve ser uma lista de 1 a 20 produtores (app, job ou status:<login>), como [github-actions]');
+        return undefined;
+    }
+    const saida = [];
+    for (const x of lista) {
+        const t = typeof x === 'string' ? x.trim() : '';
+        if (!PRODUTOR.test(t)) {
+            erros.push(`ci.produtor: ${exibir(x)} não é um produtor (app, job ou status:<login>)`);
+            continue;
+        }
+        if (!saida.includes(t))
+            saida.push(t);
+    }
+    return saida.length ? saida : undefined;
+}
+/**
+ * RM-058, integração (T6, D10 da ork-rm058integra): `ci.contexts`, os checks que a proteção da base exige, um por nome, na
+ * ordem. Lista vazia, item que não é texto de uma linha e nome repetido são erro do manifesto: a prova do CI nunca fica
+ * verde por um contexto que ninguém publica, e nunca se adivinha qual faltou.
+ */
+function lerContextos(v, erros) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (!Array.isArray(v) || v.length === 0 || v.length > 20) {
+        erros.push('ci.contexts deve ser uma lista de 1 a 20 contextos de CI (os checks que a proteção da base exige), como ["ork-verify"]');
+        return undefined;
+    }
+    const saida = [];
+    for (const x of v) {
+        const t = typeof x === 'string' ? x.trim() : '';
+        if (!t || t.length > 200 || /[\r\n]/.test(t)) {
+            erros.push(`ci.contexts: ${exibir(x)} não é o nome de um contexto de CI (texto de uma linha)`);
+            continue;
+        }
+        if (saida.includes(t)) {
+            erros.push(`ci.contexts: "${t}" aparece duas vezes`);
+            continue;
+        }
+        saida.push(t);
+    }
+    return saida.length === v.length ? saida : undefined;
+}
 /** Mesmo contrato na leitura do YAML e nos consumidores de manifesto em memoria. */
 function validarOptInPlaybook(valor) {
     if (valor === undefined)
@@ -334,6 +659,12 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
         erros.push('conduction.delegation exige thread, escopo premissas, prazo ISO, evidencia e delegado');
     }
     const worktree = mapa(dados.worktree);
+    // RM-047 (fronteira de confiança): a base vai ao git em rev-parse, log, fetch e worktree add. Nome que o
+    // git não aceita como branch (começa com `-`, tem `..`) viraria opção dele; a regra é a do check-ref-format.
+    if (worktree.base_branch !== undefined && worktree.base_branch !== null && !(0, branch_de_estado_1.branchValida)(texto(worktree.base_branch, ''))) {
+        erros.push(`worktree.base_branch invalido: ${JSON.stringify(texto(worktree.base_branch, '')).slice(0, 60)} ` +
+            '(esperado nome de branch do git, sem "-" no começo e sem "..")');
+    }
     const verify = mapa(dados.verify);
     const ci = mapa(dados.ci);
     const concurrency = mapa(dados.concurrency);
@@ -382,6 +713,9 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
     catch (e) {
         erros.push(e.message);
     }
+    const forja = lerBlocoForja(dados.forja, erros, avisos);
+    const produtores = lerProdutores(ci.produtor, erros);
+    const contextos = lerContextos(ci.contexts, erros);
     const abbrev = texto(project.abbrev, '');
     const checkAbbrev = (0, slug_1.validarAbbrev)(abbrev);
     if (!checkAbbrev.ok)
@@ -445,6 +779,8 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
     if (!codex_1.SANDBOXES_DO_CODEX.includes(sandboxDoRuntime)) {
         erros.push(`runtime.sandbox invalido: "${sandboxDoRuntime}" (aceitos: ${codex_1.SANDBOXES_DO_CODEX.join(', ')})`);
     }
+    // RM-059 (T10.4): agent teams no despacho do GO, so no piloto e desligado por padrao.
+    const agentTeams = lerAgentTeams(runtime.agent_teams, avisos);
     // Bloco B6, isolamento por tenant (precedente do incidente memory-orkmind):
     // `database_url_env` recebe o NOME da variavel de ambiente, nunca a string de conexao.
     // Uma DSN colada aqui e exatamente o defeito que fez a memoria de um produto escrever
@@ -459,10 +795,33 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             'string de conexao (base propria por tenant, sem fallback para base alheia)');
     }
     else if (variavelDaDsn !== '' && !/^[A-Z][A-Z0-9_]*$/.test(variavelDaDsn)) {
-        erros.push(`memory.database_url_env invalido: "${variavelDaDsn}" (esperado nome de variavel de ambiente, [A-Z][A-Z0-9_]*)`);
-    }
-    if (modoDeMemoria === 'orkmind' && variavelDaDsn === '') {
-        avisos.push('memory.mode: orkmind sem memory.database_url_env: o regime efetivo cai para files ' +
+        // RM-069 (D3): o valor nao entra no erro; uma DSN `chave=valor` colada aqui sairia inteira.
+        erros.push('memory.database_url_env invalido (valor omitido): esperado nome de variavel de ambiente, [A-Z][A-Z0-9_]*');
+    }
+    // RM-069 (G2, G3): a fonte de arquivo so nomeia arquivo da pasta de segredos do `ork`, e nunca junto da variavel.
+    const arquivoDaDsn = texto(memory.database_url_file, '').trim();
+    if (arquivoDaDsn.includes('://')) {
+        erros.push(`memory.database_url_file recebe o CAMINHO do arquivo com a DSN (${dsn_da_memoria_1.PREFIXO_DO_ARQUIVO_DA_DSN}<nome>), ` +
+            'nunca a string de conexao');
+    }
+    else if (arquivoDaDsn !== '' && !(0, dsn_da_memoria_1.arquivoDaDsnValido)(arquivoDaDsn)) {
+        erros.push(`memory.database_url_file invalido (valor omitido): esperado ${dsn_da_memoria_1.PREFIXO_DO_ARQUIVO_DA_DSN}<nome>, arquivo 0600 do ` +
+            'dono na pasta de segredos do ork (o manifesto nao escolhe outro caminho)');
+    }
+    if (variavelDaDsn !== '' && arquivoDaDsn !== '') {
+        erros.push('memory.database_url_env e memory.database_url_file sao exclusivos: declare uma fonte so ' +
+            '(o ork nunca cai de uma para a outra)');
+    }
+    // RM-047 (fronteira de confiança): `memory.cli` escolhe o executável que o `ork doctor`, a memória e o
+    // `ork brain` rodam. Caminho relativo apontaria para um arquivo do próprio clone; só nome procurado no
+    // PATH (o `orkmind` instalado) ou caminho absoluto escolhido por quem instalou.
+    const cliDaMemoria = texto(memory.cli, 'orkmind');
+    if (!cliDaMemoriaValido(cliDaMemoria)) {
+        erros.push(`memory.cli invalido: ${JSON.stringify(cliDaMemoria).slice(0, 60)} ` +
+            '(esperado nome de executável no PATH, como orkmind, ou caminho absoluto; caminho relativo não é aceito)');
+    }
+    if (modoDeMemoria === 'orkmind' && variavelDaDsn === '' && arquivoDaDsn === '') {
+        avisos.push('memory.mode: orkmind sem memory.database_url_file nem memory.database_url_env: o regime efetivo cai para files ' +
             '(o `ork` nao adivinha DSN, e base alheia e pior do que base nenhuma)');
     }
     const embedding = lerEmbedding(memory.embedding, variavelDaDsn, erros);
@@ -478,6 +837,8 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
     if (achado.legado) {
         avisos.push(`lendo ${exports.NOME_MANIFESTO_LEGADO} como fallback; migre para ${exports.NOME_MANIFESTO}`);
     }
+    const conhecimento = lerBlocoConhecimento(dados.conhecimento, avisos);
+    const check = lerCheck(dados.check, erros, avisos);
     const manifesto = {
         project: {
             name: nomeProjeto,
@@ -496,6 +857,7 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             effort: texto(runtime.effort, 'high'),
             provider_policy: providerPolicy,
             sandbox: sandboxDoRuntime,
+            ...(agentTeams ? { agent_teams: agentTeams } : {}),
         },
         conduction: {
             default_mode: defaultModo ?? 'classic',
@@ -509,6 +871,7 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             // P4 do ensaio da 0.5.0: o `ork thread new` cria a worktree sem flag quando a chave diz true. Ausente le
             // false, para o projeto que nunca a declarou seguir como era.
             por_thread: booleano(worktree.por_thread, false),
+            ...dependenciasDaWorktree(worktree.dependencias, erros),
         },
         verify: {
             build: verify.build === null || verify.build === undefined ? undefined : texto(verify.build, ''),
@@ -517,18 +880,26 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             typecheck: verify.typecheck === null || verify.typecheck === undefined
                 ? undefined
                 : texto(verify.typecheck, ''),
+            security_scan: verify.security_scan === null || verify.security_scan === undefined
+                ? undefined
+                : texto(verify.security_scan, ''),
             // I-54 (RM-037, D10): o preparo unico da rodada de verify, quando declarado.
             ...(typeof verify.preparo === 'string' && verify.preparo.trim() ? { preparo: verify.preparo.trim() } : {}),
         },
+        ...(check ? { check } : {}),
         ci: {
             required_for_ship: booleano(ci.required_for_ship, false),
             context: texto(ci.context, 'ork-verify'),
+            ...(contextos ? { contexts: contextos } : {}),
             command: ci.command === null || ci.command === undefined ? undefined : texto(ci.command, ''),
             external_repositories: repositoriosExternos(ci.external_repositories, erros),
+            ...(produtores ? { produtor: produtores } : {}),
         },
         concurrency: {
             max_parallel_threads: numero(concurrency.max_parallel_threads, 3),
             stale_after_min: Math.max(1, Math.trunc(numero(concurrency.stale_after_min, 240))),
+            // RM-058 N2 (D9): uma operacao pesada por vez nesta raiz, por padrao; 0 desliga a fila.
+            max_parallel_heavy: vagasPesadas(numero(concurrency.max_parallel_heavy, 1)),
         },
         liveness: { silencio_max_min: silencioMaxMin },
         handoff: {
@@ -555,6 +926,7 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
         memory: {
             mode: modoDeMemoria,
             database_url_env: variavelDaDsn,
+            ...(arquivoDaDsn ? { database_url_file: arquivoDaDsn } : {}),
             cli: texto(memory.cli, 'orkmind'),
             tenant: texto(memory.tenant, '') || nomeProjeto,
             timeout_ms: numero(memory.timeout_ms, 15000),
@@ -577,15 +949,45 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
         },
         // RM-031 KG5 (D2): expor as tools do grafo no MCP e opt-in do dono.
         grafo: lerGrafo(dados.grafo, avisos),
+        ...(conhecimento ? { conhecimento } : {}),
+        ...(forja ? { forja } : {}),
         policies: Object.fromEntries(Object.entries(mapa(dados.policies)).map(([k, v]) => [k, texto(v, '')])),
     };
     return { caminho: achado.caminho, raiz, legado: achado.legado, bytes, manifesto, erros, avisos };
 }
+/**
+ * RM-047: `memory.cli` aceito. Nome simples (procurado no PATH, sem barra e sem `-` no começo) ou caminho
+ * absoluto normalizado. Caminho relativo (`./bin/x`, `bin/x`) resolveria dentro do repositório clonado.
+ */
+function cliDaMemoriaValido(cli) {
+    // eslint-disable-next-line no-control-regex
+    if (cli === '' || /[\x00-\x1f\x7f]/.test(cli))
+        return false;
+    if (/^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/.test(cli))
+        return true;
+    return path.isAbsolute(cli) && path.normalize(cli) === cli;
+}
+/**
+ * RM-059 (A15 da revisao da ork-rm059pista): os comandos de verify e o do CI de um `orkastery.yaml` lido como texto (o
+ * do HEAD de uma branch, pelo `git show`), com as mesmas regras do `carregarManifesto`. `null` quando o texto nao abre.
+ */
+function comandosDoTextoDoManifesto(bruto) {
+    let dados;
+    try {
+        dados = mapa((0, yaml_1.lerYaml)(bruto));
+    }
+    catch {
+        return null;
+    }
+    const verify = mapa(dados.verify), ci = mapa(dados.ci);
+    const opcional = (v) => (v === null || v === undefined ? undefined : texto(v, ''));
+    return { typecheck: opcional(verify.typecheck), build: opcional(verify.build), test: opcional(verify.test), securityScan: opcional(verify.security_scan), ciCommand: opcional(ci.command) };
+}
 /** Carrega o manifesto ou encerra com mensagem acionavel (uso nos subcomandos). */
 function exigirManifesto(dirInicial = diretorioDoProjeto()) {
     const carregado = carregarManifesto(dirInicial);
     if (!carregado) {
-        throw new Error(`manifesto ${exports.NOME_MANIFESTO} nao encontrado a partir de ${dirInicial}. Rode: ork init`);
+        throw new locale_1.ErroDoCatalogo((m) => m.cli.manifestoNaoEncontrado(exports.NOME_MANIFESTO, dirInicial));
     }
     if (carregado.erros.length > 0) {
         throw new Error(`manifesto invalido (${carregado.caminho}):\n  - ${carregado.erros.join('\n  - ')}`);