@orkastery/cli 0.2.0 → 0.4.1

package/dist/playbook-capabilities.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerprintCapacidade = fingerprintCapacidade;
+exports.validarReciboCapacidade = validarReciboCapacidade;
+exports.avaliarCapacidades = avaliarCapacidades;
+exports.exigirCapacidadesRequeridas = exigirCapacidadesRequeridas;
+/** Matriz I09 sem transporte, spawn, persistencia ou ativacao. */
+const playbook_contracts_1 = require("./playbook-contracts");
+const niveis = ['help', 'transporte', 'teste', 'homologacao'];
+const versao = { type: 'integer', const: playbook_contracts_1.PLAYBOOK_VERSION };
+const schemaContexto = (0, playbook_contracts_1.objetoFechado)({
+    runtime: { type: 'string', enum: ['codex', 'claude'] },
+    versaoRuntime: playbook_contracts_1.textoPlaybook, binarioSha256: playbook_contracts_1.textoPlaybook, transporte: playbook_contracts_1.textoPlaybook,
+    configSha256: playbook_contracts_1.textoPlaybook, schemaSha256: playbook_contracts_1.textoPlaybook, codigoSha256: playbook_contracts_1.textoPlaybook,
+    escopo: (0, playbook_contracts_1.objetoFechado)({
+        projeto: playbook_contracts_1.textoPlaybook, thread: playbook_contracts_1.textoPlaybook,
+        fase: { type: 'string', enum: ['GOAL', 'PLAN', 'GO', 'CHECK', 'SHIP', 'MASTER'] },
+        dispatchId: playbook_contracts_1.textoPlaybook, sessionId: playbook_contracts_1.textoPlaybook, base: playbook_contracts_1.textoPlaybook, head: playbook_contracts_1.textoPlaybook, prova: playbook_contracts_1.textoPlaybook,
+    }),
+});
+const schemaMatriz = (0, playbook_contracts_1.objetoFechado)({
+    schemaVersion: versao, contexto: schemaContexto,
+    capacidades: (0, playbook_contracts_1.listaPlaybook)((0, playbook_contracts_1.objetoFechado)({
+        id: playbook_contracts_1.textoPlaybook,
+        evidencias: (0, playbook_contracts_1.objetoFechado)(Object.fromEntries(niveis.map(n => [n, playbook_contracts_1.textoPlaybook])), []),
+    })),
+});
+const schemaRecibo = (0, playbook_contracts_1.objetoFechado)({
+    schemaVersion: versao, id: playbook_contracts_1.textoPlaybook, fingerprint: playbook_contracts_1.textoPlaybook, capacidade: playbook_contracts_1.textoPlaybook,
+    nivel: { type: 'string', enum: niveis },
+    origem: { type: 'string', enum: ['help', 'transporte', 'deterministica', 'nativa'] },
+    fonte: (0, playbook_contracts_1.objetoFechado)({ id: playbook_contracts_1.textoPlaybook, sha256: playbook_contracts_1.textoPlaybook }),
+    comando: (0, playbook_contracts_1.listaPlaybook)(playbook_contracts_1.textoPlaybook, 1), saida: { type: 'string', maxLength: 131072 },
+    inicio: playbook_contracts_1.textoPlaybook, fim: playbook_contracts_1.textoPlaybook,
+    resultado: (0, playbook_contracts_1.objetoFechado)({
+        estado: { type: 'string', enum: ['aprovado', 'reprovado', 'unavailable'] },
+        exitCode: { type: 'integer' }, esperados: (0, playbook_contracts_1.listaPlaybook)(playbook_contracts_1.textoPlaybook),
+        executados: (0, playbook_contracts_1.listaPlaybook)(playbook_contracts_1.textoPlaybook), aprovados: (0, playbook_contracts_1.listaPlaybook)(playbook_contracts_1.textoPlaybook),
+        skipped: { type: 'integer' }, todo: { type: 'integer' },
+    }),
+});
+function exigir(condicao, campo, detalhe) {
+    if (!condicao)
+        throw new playbook_contracts_1.ContratoPlaybookInvalido(campo, detalhe);
+}
+function sha256(valor, campo) {
+    exigir(/^[a-f0-9]{64}$/.test(valor), campo, 'SHA-256 invalido');
+}
+function nomesUnicos(valores, campo) {
+    exigir(valores.every(v => v.trim().length > 0), campo, 'nome vazio');
+    exigir(new Set(valores).size === valores.length, campo, 'nome repetido');
+}
+function fingerprintCapacidade(contexto) {
+    (0, playbook_contracts_1.validarContratoPlaybook)(contexto, schemaContexto);
+    for (const k of ['binarioSha256', 'configSha256', 'schemaSha256', 'codigoSha256'])
+        sha256(contexto[k], k);
+    for (const k of ['base', 'head'])
+        exigir(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(contexto.escopo[k]), k, 'commit invalido');
+    exigir(Object.values(contexto.escopo).every(v => v.trim().length > 0) &&
+        contexto.versaoRuntime.trim().length > 0 && contexto.transporte.trim().length > 0, 'contexto', 'identidade vazia');
+    return (0, playbook_contracts_1.hashJsonPlaybook)({ schemaVersion: playbook_contracts_1.PLAYBOOK_VERSION, contexto });
+}
+function validarReciboCapacidade(valor) {
+    (0, playbook_contracts_1.validarContratoPlaybook)(valor, schemaRecibo);
+    const r = valor;
+    sha256(r.fingerprint, 'fingerprint');
+    sha256(r.fonte.sha256, 'fonte.sha256');
+    for (const campo of ['inicio', 'fim']) {
+        const instante = Date.parse(r[campo]);
+        exigir(Number.isFinite(instante) && new Date(instante).toISOString() === r[campo], campo, 'instante UTC invalido');
+    }
+    exigir(Date.parse(r.fim) >= Date.parse(r.inicio), 'fim', 'recibo termina antes de iniciar');
+    nomesUnicos([r.id], 'id');
+    nomesUnicos([r.capacidade], 'capacidade');
+    nomesUnicos([r.fonte.id], 'fonte.id');
+    const resultado = r.resultado;
+    for (const k of ['esperados', 'executados', 'aprovados'])
+        nomesUnicos(resultado[k], `resultado.${k}`);
+    exigir(resultado.exitCode >= 0 && resultado.skipped >= 0 && resultado.todo >= 0, 'resultado', 'contagem negativa');
+    exigir(resultado.aprovados.every(c => resultado.executados.includes(c)) &&
+        resultado.executados.every(c => resultado.esperados.includes(c)), 'resultado', 'casos sem correspondencia');
+    const origens = {
+        help: ['help'], transporte: ['transporte'], teste: ['deterministica', 'nativa'], homologacao: ['nativa'],
+    };
+    exigir(origens[r.nivel].includes(r.origem), 'origem', 'origem incompativel com nivel');
+    return r;
+}
+/**
+ * O consumidor Ork fornece contexto ATUAL e resolve fontes externas exatas, verificadas
+ * independentemente. Nunca construir resolverRecibo a partir do JSON do candidato.
+ * Ausencia de resolver ou de fonte nao concede selo. T07/T20 implementarao essa fronteira.
+ */
+function avaliarCapacidades(candidato, contextoAtual, requeridas, resolverRecibo) {
+    (0, playbook_contracts_1.validarContratoPlaybook)(candidato, schemaMatriz);
+    const matriz = candidato;
+    const fingerprint = fingerprintCapacidade(contextoAtual);
+    exigir(fingerprintCapacidade(matriz.contexto) === fingerprint, 'contexto', 'fingerprint atual divergente');
+    (0, playbook_contracts_1.validarContratoPlaybook)(requeridas, (0, playbook_contracts_1.listaPlaybook)(playbook_contracts_1.textoPlaybook));
+    nomesUnicos(requeridas, 'requeridas');
+    nomesUnicos(matriz.capacidades.map(c => c.id), 'capacidades');
+    const capacidades = matriz.capacidades.map(c => {
+        const provas = {};
+        const motivos = [];
+        let reprovada = false;
+        let unavailable = false;
+        for (const nivel of niveis) {
+            const id = c.evidencias[nivel];
+            if (id === undefined)
+                continue;
+            const fonte = resolverRecibo?.(id);
+            if (fonte === undefined || fonte === null) {
+                motivos.push(`${nivel}: fonte externa ausente`);
+                unavailable = true;
+                continue;
+            }
+            const recibo = validarReciboCapacidade(fonte);
+            exigir(recibo.id === id && recibo.capacidade === c.id && recibo.nivel === nivel, nivel, 'recibo de outra capacidade ou nivel');
+            exigir(recibo.fingerprint === fingerprint, nivel, 'recibo de outro fingerprint');
+            const r = recibo.resultado;
+            const casosCompletos = r.esperados.length > 0 && r.esperados.length === r.executados.length &&
+                r.executados.length === r.aprovados.length && r.skipped === 0 && r.todo === 0;
+            provas[nivel] = r.estado === 'aprovado' && r.exitCode === 0 && casosCompletos;
+            if (!provas[nivel]) {
+                motivos.push(`${nivel}: ${r.estado}, casos completos=${casosCompletos}, exitCode=${r.exitCode}`);
+                if (r.estado === 'unavailable')
+                    unavailable = true;
+                else
+                    reprovada = true;
+            }
+        }
+        const homologada = provas.transporte === true && provas.teste === true && provas.homologacao === true &&
+            !reprovada && !unavailable;
+        return {
+            id: c.id, observadaNoHelp: provas.help === true, disponivelNoTransporte: provas.transporte === true,
+            testada: provas.teste === true, homologada,
+            estado: reprovada ? 'reprovada' : unavailable ? 'unavailable' :
+                homologada ? 'homologada' : 'pendente',
+            motivos,
+        };
+    });
+    const requeridasSemDemonstracao = requeridas.filter(id => !capacidades.some(c => c.id === id && c.homologada));
+    return { schemaVersion: playbook_contracts_1.PLAYBOOK_VERSION, fingerprint, capacidades,
+        requeridasAtendidas: requeridas.length > 0 && requeridasSemDemonstracao.length === 0,
+        requeridasSemDemonstracao };
+}
+function exigirCapacidadesRequeridas(...parametros) {
+    const matriz = avaliarCapacidades(...parametros);
+    exigir(matriz.requeridasAtendidas, 'requeridas', `sem demonstracao: ${matriz.requeridasSemDemonstracao.join(', ') || 'coorte vazia'}`);
+    return matriz;
+}

package/dist/playbook-contracts.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textoPlaybook = exports.ContratoPlaybookInvalido = exports.MAX_RESULT_BYTES = exports.JSON_SCHEMA_DIALECT = exports.PLAYBOOK_VERSION = void 0;
+exports.validarSchemaPlaybook = validarSchemaPlaybook;
+exports.validarContratoPlaybook = validarContratoPlaybook;
+exports.hashJsonPlaybook = hashJsonPlaybook;
+exports.objetoFechado = objetoFechado;
+exports.listaPlaybook = listaPlaybook;
+exports.validarResultadoFasePlaybook = validarResultadoFasePlaybook;
+/** Contratos puros I09. Validar formato nao concede autoridade nem executa verify. */
+const node_crypto_1 = require("node:crypto");
+exports.PLAYBOOK_VERSION = 1;
+exports.JSON_SCHEMA_DIALECT = 'https://json-schema.org/draft/2020-12/schema';
+exports.MAX_RESULT_BYTES = 256 * 1024;
+class ContratoPlaybookInvalido extends Error {
+    campo;
+    constructor(campo, detalhe) {
+        super(`${campo}: ${detalhe}`);
+        this.campo = campo;
+        this.name = 'ContratoPlaybookInvalido';
+    }
+}
+exports.ContratoPlaybookInvalido = ContratoPlaybookInvalido;
+function exigir(condicao, campo, detalhe) {
+    if (!condicao)
+        throw new ContratoPlaybookInvalido(campo, detalhe);
+}
+function objeto(valor) {
+    return valor !== null && typeof valor === 'object' && !Array.isArray(valor) &&
+        [Object.prototype, null].includes(Object.getPrototypeOf(valor));
+}
+/** Somente dados JSON, sem getters, prototipos customizados, ciclos ou arrays esparsos. */
+function exigirJson(valor) {
+    const ativos = new Set();
+    let nos = 0;
+    function visitar(v, profundidade) {
+        exigir(++nos <= exports.MAX_RESULT_BYTES && profundidade <= 32, '$', 'JSON excede limite estrutural');
+        if (v === null || typeof v === 'string' || typeof v === 'boolean')
+            return;
+        if (typeof v === 'number') {
+            exigir(Number.isFinite(v), '$', 'numero JSON invalido');
+            return;
+        }
+        exigir(Array.isArray(v) || objeto(v), '$', 'esperado dado JSON simples');
+        exigir(!ativos.has(v), '$', 'ciclo JSON');
+        ativos.add(v);
+        const chaves = Reflect.ownKeys(v);
+        if (Array.isArray(v)) {
+            exigir(chaves.length === v.length + 1, '$', 'array esparso ou com campos extras');
+        }
+        for (const chave of chaves) {
+            if (Array.isArray(v) && chave === 'length')
+                continue;
+            exigir(typeof chave === 'string', '$', 'chave nao JSON');
+            const d = Object.getOwnPropertyDescriptor(v, chave);
+            exigir(d.enumerable && 'value' in d, '$', 'campo nao JSON');
+            if (Array.isArray(v))
+                exigir(/^(0|[1-9][0-9]*)$/.test(chave) && Number(chave) < v.length, '$', 'indice invalido');
+            visitar(d.value, profundidade + 1);
+        }
+        ativos.delete(v);
+    }
+    visitar(valor, 0);
+    exigir(Buffer.byteLength(JSON.stringify(valor), 'utf8') <= exports.MAX_RESULT_BYTES, '$', 'JSON excede 256 KiB');
+}
+function primitivo(v) {
+    return v === null || typeof v === 'string' || typeof v === 'boolean' ||
+        (typeof v === 'number' && Number.isSafeInteger(v));
+}
+/** Subconjunto fechado. $ref, combinadores, pattern e keywords desconhecidas falham. */
+function validarSchemaPlaybook(schema) {
+    exigirJson(schema);
+    function visitar(s, campo, nivel) {
+        exigir(objeto(s), campo, 'schema deve ser objeto');
+        exigir(nivel <= 24, campo, 'schema profundo demais');
+        const porTipo = {
+            object: ['properties', 'required', 'additionalProperties'],
+            array: ['items', 'minItems', 'maxItems'],
+            string: ['minLength', 'maxLength'],
+            integer: [], boolean: [], null: [],
+        };
+        exigir(typeof s.type === 'string' && Object.hasOwn(porTipo, s.type), campo, 'tipo nao suportado');
+        const permitidas = ['type', 'const', 'enum', ...porTipo[s.type]];
+        if (nivel === 0)
+            permitidas.push('$schema');
+        for (const chave of Object.keys(s))
+            exigir(permitidas.includes(chave), `${campo}.${chave}`, 'keyword nao suportada');
+        if (Object.hasOwn(s, '$schema'))
+            exigir(s.$schema === exports.JSON_SCHEMA_DIALECT, campo, 'dialeto nao suportado');
+        if (Object.hasOwn(s, 'const'))
+            exigir(primitivo(s.const), campo, 'const deve ser primitivo');
+        if (Object.hasOwn(s, 'enum')) {
+            exigir(Array.isArray(s.enum) && s.enum.length > 0 && s.enum.every(primitivo), campo, 'enum invalido');
+            exigir(new Set(s.enum).size === s.enum.length, campo, 'enum repetido');
+        }
+        for (const [min, max] of [['minLength', 'maxLength'], ['minItems', 'maxItems']]) {
+            for (const k of [min, max])
+                if (Object.hasOwn(s, k)) {
+                    exigir(Number.isSafeInteger(s[k]) && s[k] >= 0, campo, `${k} invalido`);
+                }
+            if (Object.hasOwn(s, min) && Object.hasOwn(s, max))
+                exigir(s[min] <= s[max], campo, 'limites invertidos');
+        }
+        if (s.type === 'object') {
+            exigir(objeto(s.properties) && s.additionalProperties === false && Array.isArray(s.required), campo, 'objeto deve ser fechado');
+            exigir(s.required.every(k => typeof k === 'string' && Object.hasOwn(s.properties, k)), campo, 'required desconhecido');
+            exigir(new Set(s.required).size === s.required.length, campo, 'required repetido');
+            for (const [k, filho] of Object.entries(s.properties))
+                visitar(filho, `${campo}.properties.${k}`, nivel + 1);
+        }
+        if (s.type === 'array')
+            visitar(s.items, `${campo}.items`, nivel + 1);
+        // Nao aceitar restricoes impossiveis como const de outro tipo ou fora do enum.
+        const valores = Object.hasOwn(s, 'const') ? [s.const] : s.enum ?? [];
+        for (const v of valores)
+            validarValor(v, s, campo);
+    }
+    visitar(schema, '$schema', 0);
+}
+function validarValor(v, s, campo) {
+    const tipoOk = s.type === 'object' ? objeto(v) : s.type === 'array' ? Array.isArray(v) :
+        s.type === 'null' ? v === null : s.type === 'integer' ? Number.isSafeInteger(v) : typeof v === s.type;
+    exigir(tipoOk, campo, `tipo esperado: ${s.type}`);
+    if (Object.hasOwn(s, 'const'))
+        exigir(v === s.const, campo, 'const divergente');
+    if (Array.isArray(s.enum))
+        exigir(s.enum.includes(v), campo, 'valor fora do enum');
+    if (typeof v === 'string' || Array.isArray(v)) {
+        const tamanho = typeof v === 'string' ? [...v].length : v.length;
+        const min = s[typeof v === 'string' ? 'minLength' : 'minItems'];
+        const max = s[typeof v === 'string' ? 'maxLength' : 'maxItems'];
+        exigir(min === undefined || tamanho >= min, campo, 'tamanho abaixo do minimo');
+        exigir(max === undefined || tamanho <= max, campo, 'tamanho acima do maximo');
+    }
+    if (objeto(v)) {
+        const props = s.properties;
+        for (const k of s.required)
+            exigir(Object.hasOwn(v, k), `${campo}.${k}`, 'campo obrigatorio ausente');
+        for (const k of Object.keys(v)) {
+            exigir(Object.hasOwn(props, k), `${campo}.${k}`, 'campo desconhecido');
+            validarValor(v[k], props[k], `${campo}.${k}`);
+        }
+    }
+    if (Array.isArray(v))
+        v.forEach((item, i) => validarValor(item, s.items, `${campo}[${i}]`));
+}
+function validarContratoPlaybook(valor, schema) {
+    validarSchemaPlaybook(schema);
+    exigirJson(valor);
+    validarValor(valor, schema, '$');
+}
+/** Canonizacao independente da ordem de propriedades; arrays preservam sua ordem. */
+function hashJsonPlaybook(valor) {
+    exigirJson(valor);
+    function canonico(v) {
+        if (Array.isArray(v))
+            return `[${v.map(canonico).join(',')}]`;
+        if (objeto(v))
+            return `{${Object.keys(v).sort().map(k => `${JSON.stringify(k)}:${canonico(v[k])}`).join(',')}}`;
+        return JSON.stringify(v);
+    }
+    return (0, node_crypto_1.createHash)('sha256').update(canonico(valor)).digest('hex');
+}
+exports.textoPlaybook = { type: 'string', minLength: 1, maxLength: 4096 };
+function objetoFechado(properties, required = Object.keys(properties)) {
+    return { type: 'object', properties, required, additionalProperties: false };
+}
+function listaPlaybook(items, minItems = 0) {
+    return { type: 'array', items, minItems, maxItems: 256 };
+}
+const schemaFase = objetoFechado({
+    schemaVersion: { type: 'integer', const: exports.PLAYBOOK_VERSION },
+    fase: { type: 'string', enum: ['GOAL', 'PLAN', 'GO', 'CHECK', 'SHIP', 'MASTER'] },
+    slug: exports.textoPlaybook, sessionId: exports.textoPlaybook, dispatchId: exports.textoPlaybook,
+    estado: { type: 'string', enum: ['concluida', 'falhou', 'interrompida'] },
+    reciboId: exports.textoPlaybook,
+    resultado: objetoFechado({
+        produtoHomologado: { type: 'boolean' }, GOIntegralConcluido: { type: 'boolean' }, checkpoint: exports.textoPlaybook,
+    }),
+});
+/** Apenas contrato e correlacao. T06 consumira a prova terminal externa de I04. */
+function validarResultadoFasePlaybook(valor, esperado) {
+    validarContratoPlaybook(valor, schemaFase);
+    const r = valor;
+    for (const k of ['fase', 'slug', 'sessionId', 'dispatchId'])
+        exigir(r[k] === esperado[k], k, 'despacho divergente');
+    return r;
+}

package/dist/policies.js

@@ -15,8 +15,10 @@ exports.POLICIES_CONHECIDAS = void 0;
 exports.procurarSegredos = procurarSegredos;
 exports.policiesDesconhecidas = policiesDesconhecidas;
 exports.avaliarPolicies = avaliarPolicies;
+exports.avisos = avisos;
 exports.bloqueantes = bloqueantes;
 exports.motivoDominante = motivoDominante;
+exports.linhasDeAviso = linhasDeAviso;
 exports.textoDeViolacoes = textoDeViolacoes;
 /**
  * Variaveis que REDIRECIONAM o despacho do `claude` para um provider pago.
@@ -73,6 +75,24 @@ exports.POLICIES_CONHECIDAS = {
         quando: ['ship'],
         descricao: 'proibe entregar sem branch de thread (push direto na base)',
     },
+    // RM-008 (fatia 3): licoes do loop de aprendizado que o `ork` sabe conferir sem ambiguidade.
+    // O nome e o mesmo que o `ork licoes` propoe, para a proposta ser declarada como veio.
+    verify_regression: {
+        quando: ['phase.dispatch'],
+        descricao: 'avisa quando o bloco que contem GO sai sem baseline gravada',
+    },
+    verify_failed: {
+        quando: ['phase.dispatch'],
+        descricao: 'avisa quando o bloco que contem GO sai sem baseline gravada (mesma conferencia de verify_regression)',
+    },
+    runtime_unavailable: {
+        quando: ['phase.dispatch'],
+        descricao: 'avisa quando o bloco despachado nao declara runtime de fallback',
+    },
+    tree_blocked: {
+        quando: ['ship'],
+        descricao: 'avisa quando a branch da thread esta atras da base',
+    },
 };
 function severidade(bruta) {
     if (bruta === 'block' || bruta === 'warn' || bruta === 'off')
@@ -87,6 +107,8 @@ function policiesDesconhecidas(manifesto) {
 function avaliarPolicies(manifesto, ctx) {
     const declaradas = manifesto.policies ?? {};
     const violacoes = [];
+    // verify_regression e verify_failed conferem a mesma coisa: um aviso so, com o nome da primeira declarada.
+    let baselineJaAvaliada = false;
     for (const [nome, bruta] of Object.entries(declaradas)) {
         const conhecida = exports.POLICIES_CONHECIDAS[nome];
         if (!conhecida || !conhecida.quando.includes(ctx.gate))
@@ -148,9 +170,52 @@ function avaliarPolicies(manifesto, ctx) {
             }
             continue;
         }
+        if (nome === 'verify_regression' || nome === 'verify_failed') {
+            if (baselineJaAvaliada)
+                continue;
+            baselineJaAvaliada = true;
+            if (ctx.blocoComGo === true && ctx.temBaseline === false) {
+                violacoes.push({
+                    policy: nome,
+                    severidade: sev,
+                    motivo: 'policy.violation',
+                    detalhe: 'o bloco que contem GO vai sair sem baseline: uma falha que ja existia passaria por regressao desta thread',
+                    correcao: `ork verify ${ctx.threadId ?? '<thread>'} --baseline`,
+                });
+            }
+            continue;
+        }
+        if (nome === 'runtime_unavailable') {
+            if (Array.isArray(ctx.fallbackDoBloco) && ctx.fallbackDoBloco.length === 0) {
+                violacoes.push({
+                    policy: nome,
+                    severidade: sev,
+                    motivo: 'policy.violation',
+                    detalhe: 'o bloco nao declara runtime de fallback: se o runtime cair, a fase para ate alguem trocar a mao',
+                    correcao: `ork setup ${ctx.modo ?? '<modo>'} --bloco ${ctx.bloco ?? 'N'} --fallback <runtime:modelo>`,
+                });
+            }
+            continue;
+        }
+        if (nome === 'tree_blocked') {
+            if (ctx.branchAtrasDaBase === true) {
+                violacoes.push({
+                    policy: nome,
+                    severidade: sev,
+                    motivo: 'policy.violation',
+                    detalhe: `a branch "${ctx.de ?? 'da thread'}" esta atras de "${ctx.para ?? ctx.baseBranch ?? 'base'}": a entrega mistura a mudanca com o que a base ja andou`,
+                    correcao: `ork worktree sync ${ctx.threadId ?? '<thread>'}`,
+                });
+            }
+            continue;
+        }
     }
     return violacoes;
 }
+/** So as violacoes com severidade `warn` (as que registram e seguem). */
+function avisos(violacoes) {
+    return violacoes.filter((v) => v.severidade === 'warn');
+}
 /** So as violacoes com severidade `block` (as que reprovam em qualquer modo). */
 function bloqueantes(violacoes) {
     return violacoes.filter((v) => v.severidade === 'block');
@@ -168,6 +233,13 @@ function motivoDominante(violacoes) {
         ? 'cost.violation'
         : 'policy.violation';
 }
+/** RM-008 (fatia 3): as linhas de aviso (policies em warn) para a saida do CLI. Nada quando nao ha aviso. */
+function linhasDeAviso(violacoes, recuo = '  ') {
+    return avisos(violacoes).flatMap((v) => [
+        `${recuo}aviso da policy ${v.policy}: ${v.detalhe}`,
+        `${recuo}  correcao: ${v.correcao}`,
+    ]);
+}
 /** Texto das violacoes para a saida do CLI. */
 function textoDeViolacoes(violacoes) {
     return violacoes

package/dist/portfolio-context.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectPortfolio = inspectPortfolio;
+/** Inspeção por identidade: o estado do catálogo não é inferido de ciclos. */
+const portfolio_1 = require("./portfolio");
+const objective_1 = require("./objective");
+const statusLabels = {
+    awaiting_approval: 'Aguardando aprovação', running: 'Em andamento', paused: 'Pausado', validated: 'Validado no ciclo', stopped: 'Interrompido',
+};
+function inspectPortfolio(root, id, readCycles = objective_1.listObjectives) {
+    if (!/^(prod|proj|init)-[a-z0-9][a-z0-9-]{2,47}$/.test(id))
+        throw new Error('portfolio.id: identidade inválida');
+    const entity = (0, portfolio_1.findEntity)(root, id);
+    if (!entity)
+        throw new Error('portfolio.unavailable: entidade indisponível');
+    const portfolio = (0, portfolio_1.readPortfolio)(root);
+    const parentId = entity.kind === 'project' ? entity.productId : entity.kind === 'initiative' ? entity.projectId : null;
+    const parent = parentId ? (0, portfolio_1.findEntity)(root, parentId) : null;
+    const result = {
+        schema: 'ork.portfolio-context/v1', entity, parent,
+        origin: { authority: 'ork.portfolio', schema: portfolio.schema, reference: `portfolio:${entity.id}`, catalogUpdatedAt: portfolio.updatedAt, observedAt: new Date().toISOString(), creationOperationId: entity.creationOperationId ?? null },
+        cycles: [], cyclesState: 'available', cyclesMessage: 'Nenhum ciclo vinculado',
+        gaps: ['delivery.receipt_not_loaded'], conflicts: [], references: parentId ? [{ kind: 'entity', id: parentId }] : [],
+    };
+    if (!entity.creationOperationId)
+        result.gaps.push('origin.legacy');
+    if (parentId && !parent)
+        result.gaps.push('parent.unavailable');
+    try {
+        for (const cycle of readCycles(root)) {
+            const scope = cycle.envelope.portfolio;
+            if (!scope)
+                continue;
+            const matches = entity.kind === 'product' ? scope.productId === entity.id
+                : entity.kind === 'project' ? scope.projectId === entity.id
+                    : scope.projectId === entity.projectId && (scope.delivery === 'project' || scope.initiativeIds.includes(entity.id));
+            if (!matches)
+                continue;
+            const relation = entity.kind === 'product' || (entity.kind === 'initiative' && scope.delivery === 'project') ? 'project_context'
+                : scope.delivery === 'project' ? 'project_delivery' : 'initiative_delivery';
+            result.cycles.push({ id: cycle.id, title: cycle.title, status: cycle.status, statusLabel: statusLabels[cycle.status] ?? 'Estado não confirmado', relation,
+                projectId: scope.projectId, initiativeIds: [...scope.initiativeIds], updatedAt: cycle.updatedAt, envelopeHash: cycle.envelope.hash, entityDeliveryProven: false });
+            result.references.push({ kind: 'objective', id: cycle.id });
+            if (entity.status === 'delivered' && ['running', 'paused', 'awaiting_approval'].includes(cycle.status)) {
+                result.conflicts.push({ code: 'entity.delivered_cycle_open', cycleId: cycle.id });
+            }
+        }
+        result.cycles.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || a.id.localeCompare(b.id));
+        if (result.cycles.length)
+            result.cyclesMessage = 'Ciclos vinculados; escopo e estado independentes do catálogo';
+    }
+    catch {
+        result.cycles = [];
+        result.conflicts = [];
+        result.references = result.references.filter((reference) => reference.kind === 'entity');
+        result.cyclesState = 'unavailable';
+        result.cyclesMessage = 'Consulta de ciclos indisponível';
+        result.gaps.push('cycles.unavailable');
+    }
+    return result;
+}