@orkastery/cli 0.2.0 → 0.3.0

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/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;
+}

package/dist/portfolio.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPortfolio = readPortfolio;
+exports.findEntity = findEntity;
+exports.createProduct = createProduct;
+exports.createProject = createProject;
+exports.createInitiative = createInitiative;
+exports.createOperationEntity = createOperationEntity;
+exports.listEntities = listEntities;
+exports.assertCycleScope = assertCycleScope;
+/** Catálogo determinístico de produto -> projeto -> iniciativa. */
+const fs = __importStar(require("node:fs"));
+const project_state_1 = require("./project-state");
+const company_brain_journal_1 = require("./company-brain-journal");
+const util_1 = require("./util");
+const creation_operation_store_1 = require("./creation-operation-store");
+const ID = /^(prod|proj|init)-[a-z0-9][a-z0-9-]{2,47}$/;
+const PREFIX = { product: 'prod-', project: 'proj-', initiative: 'init-' };
+const statuses = ['idea', 'planned', 'ready', 'in_progress', 'validating', 'delivered', 'blocked', 'cancelled'];
+const unique = (values = []) => [...new Set(values.map((v) => v.trim()).filter(Boolean))];
+function file(root) { return (0, project_state_1.stateFile)(root, 'portfolio.json'); }
+function empty() { return { schema: 'ork.portfolio/v1', updatedAt: (0, util_1.agora)(), products: [], projects: [], initiatives: [] }; }
+function readPortfolio(root) {
+    const target = file(root);
+    if (!fs.existsSync(target))
+        return empty();
+    const value = (0, util_1.lerJson)(target);
+    if (value.schema !== 'ork.portfolio/v1' || !Array.isArray(value.products) || !Array.isArray(value.projects) || !Array.isArray(value.initiatives)) {
+        throw new Error('portfolio inválido');
+    }
+    return value;
+}
+function persist(root, value) { value.updatedAt = (0, util_1.agora)(); (0, company_brain_journal_1.replaceWithJournal)(file(root), value); return value; }
+function mutatePortfolio(root, run) {
+    return (0, creation_operation_store_1.withCreationLock)(root, 'portfolio', () => (0, company_brain_journal_1.portfolioMutation)(file(root), run));
+}
+function validateBase(kind, input) {
+    if (!ID.test(input.id) || !input.id.startsWith(PREFIX[kind]))
+        throw new Error(`${kind} exige id ${PREFIX[kind]}...`);
+    if (!input.title.trim() || input.title.length > 160)
+        throw new Error('título deve ter entre 1 e 160 caracteres');
+    if (input.status && !statuses.includes(input.status))
+        throw new Error('status de portfólio inválido');
+}
+function findEntity(root, id) {
+    const p = readPortfolio(root);
+    return [...p.products, ...p.projects, ...p.initiatives].find((item) => item.id === id) ?? null;
+}
+function createProduct(root, input) {
+    return mutatePortfolio(root, () => {
+        validateBase('product', input);
+        if (findEntity(root, input.id))
+            throw new Error(`entidade ${input.id} já existe`);
+        const product = { kind: 'product', id: input.id, title: input.title.trim(), description: input.description?.trim() ?? '', ownerId: input.ownerId?.trim() || null, status: input.status ?? 'idea', acceptanceCriteria: unique(input.acceptanceCriteria), version: 1 };
+        const p = readPortfolio(root);
+        p.products.push(product);
+        persist(root, p);
+        return product;
+    });
+}
+function createProject(root, input) {
+    return mutatePortfolio(root, () => createProjectLocked(root, input));
+}
+function createProjectLocked(root, input, operationId) {
+    validateBase('project', input);
+    if (findEntity(root, input.id))
+        throw new Error(`entidade ${input.id} já existe`);
+    const parent = findEntity(root, input.productId);
+    if (!parent || parent.kind !== 'product')
+        throw new Error(`produto ${input.productId} não encontrado`);
+    const project = { kind: 'project', id: input.id, productId: input.productId, title: input.title.trim(), description: input.description?.trim() ?? '', ownerId: input.ownerId?.trim() || null, status: input.status ?? 'idea', workspaceIds: unique(input.workspaceIds), acceptanceCriteria: unique(input.acceptanceCriteria), version: 1 };
+    if (operationId)
+        Object.assign(project, { creationOperationId: operationId });
+    const p = readPortfolio(root);
+    p.projects.push(project);
+    persist(root, p);
+    return project;
+}
+function createInitiative(root, input) {
+    return mutatePortfolio(root, () => createInitiativeLocked(root, input));
+}
+function createInitiativeLocked(root, input, operationId) {
+    validateBase('initiative', input);
+    if (findEntity(root, input.id))
+        throw new Error(`entidade ${input.id} já existe`);
+    const parent = findEntity(root, input.projectId);
+    if (!parent || parent.kind !== 'project')
+        throw new Error(`projeto ${input.projectId} não encontrado`);
+    const dependencies = unique(input.dependsOn);
+    for (const id of dependencies) {
+        const dependency = findEntity(root, id);
+        if (!dependency || dependency.kind !== 'initiative')
+            throw new Error(`dependência ${id} não encontrada`);
+        if (dependency.projectId !== input.projectId)
+            throw new Error('dependências devem pertencer ao mesmo projeto');
+    }
+    const initiative = { kind: 'initiative', id: input.id, projectId: input.projectId, title: input.title.trim(), description: input.description?.trim() ?? '', ownerId: input.ownerId?.trim() || null, status: input.status ?? 'idea', dependsOn: dependencies, acceptanceCriteria: unique(input.acceptanceCriteria), version: 1 };
+    if (operationId)
+        Object.assign(initiative, { creationOperationId: operationId });
+    const p = readPortfolio(root);
+    p.initiatives.push(initiative);
+    persist(root, p);
+    return initiative;
+}
+/** CAS do pai e origem do efeito são persistidos sob o mesmo lock dos escritores legados. */
+function createOperationEntity(root, operationId, principal) {
+    return mutatePortfolio(root, () => {
+        const op = (0, creation_operation_store_1.readCreationOperation)(root, operationId, principal);
+        const input = op.request.entity;
+        if (!input || ['compensating', 'compensated', 'compensation_failed'].includes(op.state))
+            throw new Error('creation.conflict: ação não cria entidade');
+        const parent = findEntity(root, input.parentId);
+        if (!parent || parent.version !== op.request.expectedParentVersion)
+            throw new Error('creation.conflict: versão do pai alterada');
+        const existing = findEntity(root, input.id);
+        if (existing) {
+            if (existing.creationOperationId !== operationId || existing.version !== 1)
+                throw new Error('creation.conflict: entidade alheia ou alterada');
+            return existing;
+        }
+        const common = { id: input.id, title: input.title, description: input.description, acceptanceCriteria: input.acceptanceCriteria };
+        if (input.kind === 'project')
+            return createProjectLocked(root, { ...common, productId: input.parentId, workspaceIds: op.request.workspaceIds }, operationId);
+        return createInitiativeLocked(root, { ...common, projectId: input.parentId }, operationId);
+    });
+}
+function listEntities(root, kind, parentId) {
+    const p = readPortfolio(root);
+    const values = kind === 'product' ? p.products : kind === 'project' ? p.projects : kind === 'initiative' ? p.initiatives : [...p.products, ...p.projects, ...p.initiatives];
+    return parentId ? values.filter((item) => item.kind === 'project' ? item.productId === parentId : item.kind === 'initiative' ? item.projectId === parentId : false) : values;
+}
+function assertCycleScope(root, scope) {
+    const project = findEntity(root, scope.projectId);
+    if (!project || project.kind !== 'project')
+        throw new Error(`projeto ${scope.projectId} não encontrado`);
+    const ids = unique(scope.initiativeIds);
+    if (scope.delivery === 'project' && ids.length)
+        throw new Error('escopo de projeto não aceita iniciativas');
+    if (scope.delivery === 'initiatives' && !ids.length)
+        throw new Error('escopo de iniciativas exige ao menos uma iniciativa');
+    for (const id of ids) {
+        const initiative = findEntity(root, id);
+        if (!initiative || initiative.kind !== 'initiative' || initiative.projectId !== scope.projectId)
+            throw new Error(`iniciativa ${id} não pertence ao projeto`);
+    }
+    return { ...scope, initiativeIds: ids };
+}