@orkastery/cli 0.5.6 → 0.6.1

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

@@ -61,8 +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';
@@ -98,7 +101,7 @@ function dirEstado(raiz) {
     // 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 Error(`estado.link: ${exports.DIR_ESTADO} é link simbólico; o estado do ork fica numa pasta de verdade dentro da raiz. Remova o link.`);
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.dirEstadoLink(exports.DIR_ESTADO));
     }
     return dir;
 }
@@ -140,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]);
@@ -153,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)
@@ -165,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') {
@@ -205,6 +226,116 @@ 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;
@@ -264,6 +395,123 @@ function lerBlocoConhecimento(v, avisos) {
         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)
@@ -465,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)
@@ -521,7 +772,12 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
     // Runtime de despacho: so os homologados passam. Um typo aqui viraria erro apenas na
     // hora do despacho, com a thread ja aberta; reprovar no manifesto e mais barato.
     const adapterDeRuntime = texto(runtime.adapter, runtimes_1.RUNTIME_PADRAO);
-    if (!(0, runtimes_1.runtimeConhecido)(adapterDeRuntime)) {
+    if ((0, runtimes_1.runtimeConhecido)(adapterDeRuntime) && !(0, runtimes_1.runtimeDoManifesto)(adapterDeRuntime)) {
+        // RM-067 (F4): runtime de bloco no setup, nunca o padrao do projeto.
+        erros.push(`runtime.adapter fora do padrao do projeto: "${adapterDeRuntime}" entra por ork setup <modo> --bloco N --runtime ` +
+            `${adapterDeRuntime} --model <modelo> ou por ork phase run --runtime ${adapterDeRuntime} (o padrao aceita: ${runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')})`);
+    }
+    else if (!(0, runtimes_1.runtimeDoManifesto)(adapterDeRuntime)) {
         erros.push(`runtime.adapter desconhecido: "${adapterDeRuntime}" (homologados: ${runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')})`);
     }
     const sandboxDoRuntime = texto(runtime.sandbox, codex_1.SANDBOX_PADRAO);
@@ -544,7 +800,22 @@ 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_]*)`);
+        // 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
@@ -554,8 +825,8 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
         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 === '') {
-        avisos.push('memory.mode: orkmind sem memory.database_url_env: o regime efetivo cai para files ' +
+    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);
@@ -572,6 +843,7 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
         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,
@@ -604,6 +876,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, ''),
@@ -612,14 +885,20 @@ 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),
@@ -652,6 +931,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),
@@ -675,6 +955,7 @@ 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 };
@@ -705,7 +986,7 @@ function comandosDoTextoDoManifesto(bruto) {
     }
     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), ciCommand: opcional(ci.command) };
+    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()) {