@orkastery/cli 0.2.0 → 0.4.1

package/dist/ci.js

@@ -0,0 +1,223 @@
+"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.motivoDiferimentoCi = motivoDiferimentoCi;
+exports.repositorioGitHub = repositorioGitHub;
+exports.consultarCi = consultarCi;
+exports.executarCi = executarCi;
+exports.lintDoBundle = lintDoBundle;
+exports.prepararBundleCi = prepararBundleCi;
+exports.executarBundleCi = executarBundleCi;
+const util_1 = require("./util");
+const verify_1 = require("./verify");
+const verify_2 = require("./verify");
+const claims_1 = require("./claims");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const claim_lint_1 = require("./claim-lint");
+const integracoes_locais_1 = require("./integracoes-locais");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+const MARCADORES_DE_HOST = [
+    /(^|[\s;&|])\/home\//,
+    /(^|[\s;&|])localhost(?=[:/\s;&|]|$)/,
+    /verify-company-brain-live\.cjs/,
+];
+// Alguns verificadores misturam casos hermeticos com casos que, por contrato, leem
+// repositorios irmaos ou o estado local da thread. Classificar por executavel inteiro
+// dispensaria tambem os casos hermeticos; a unidade correta e o caso selecionado.
+const CASOS_DE_VERIFICADOR_LOCAIS = [
+    /verify-goal-c2-b3\.cjs\s+(?:P2|P3|P4|P5)(?:\s|$)/,
+    /verify-check-c2-b3\.cjs\s+(?:docs-metrics|d12-ratification)(?:\s|$)/,
+];
+const CASOS_DE_VERIFICADOR_COM_INTEGRACAO_LOCAL = [
+    /verify-check-c2-b3\.cjs\s+channel-offer(?:\s|$)/,
+];
+function exigeIntegracaoLocal(command) {
+    return [...command.matchAll(/(?:^|[\s/])([a-z0-9-]+\.test\.js)(?=$|[\s;&|])/g)]
+        .some(match => integracoes_locais_1.TESTES_DE_INTEGRACAO_LOCAL.has(match[1]));
+}
+/**
+ * CI hosted cannot impersonate an installed host.  Those claims are not dropped:
+ * the bundle names them as deferred and `ork ship` still runs the complete local
+ * verification before consulting GitHub.  Only checkout-hermetic claims execute in
+ * the independent runner.
+ */
+function motivoDiferimentoCi(claim, raiz) {
+    // `git ls-files` aceita um pathspec absoluto que esteja dentro desta worktree,
+    // mas o mesmo texto aponta para uma worktree inexistente no runner hospedado.
+    if (path.isAbsolute(claim.arquivo))
+        return 'artifact-not-in-checkout';
+    const tracked = (0, util_1.exec)('git', ['ls-files', '--error-unmatch', '--', claim.arquivo], raiz);
+    if (!tracked.ok)
+        return 'artifact-not-in-checkout';
+    if (claim.verificar.some((command) => MARCADORES_DE_HOST.some((marker) => marker.test(command)))) {
+        return 'host-runtime-required';
+    }
+    if (claim.verificar.some((command) => CASOS_DE_VERIFICADOR_LOCAIS.some((caso) => caso.test(command)))) {
+        return 'host-runtime-required';
+    }
+    if (claim.verificar.some((command) => exigeIntegracaoLocal(command)
+        || CASOS_DE_VERIFICADOR_COM_INTEGRACAO_LOCAL.some((caso) => caso.test(command)))) {
+        return 'local-integration-required';
+    }
+    return null;
+}
+function repositorioGitHub(url) {
+    const match = url.trim().replace(/\.git$/, '').match(/(?:github\.com[/:])([^/]+\/[^/]+)$/i);
+    return match?.[1] ?? null;
+}
+function executorPadrao(input) {
+    return (0, util_1.exec)('gh', [
+        'api', `repos/${input.repository}/commits/${input.sha}/check-runs`,
+        '-H', 'Accept: application/vnd.github+json',
+    ], process.cwd(), 120000);
+}
+function consultarCi(carregado, sha, remoto = 'origin', executor = executorPadrao) {
+    const { ci } = carregado.manifesto;
+    const context = ci.context || 'ork-verify';
+    if (!ci.required_for_ship)
+        return { schema: 'ork.ci-status/v1', required: false, ok: true, provider: 'github', repository: null, sha, context, state: 'disabled', url: null, detail: 'gate de CI não exigido pelo manifesto' };
+    const remote = (0, util_1.exec)('git', ['remote', 'get-url', remoto], carregado.raiz);
+    const repository = remote.ok ? repositorioGitHub(remote.stdout) : null;
+    if (!repository)
+        return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository: null, sha, context, state: 'unavailable', url: null, detail: `remoto ${remoto} não é um repositório GitHub reconhecível` };
+    const result = executor({ repository, sha, context });
+    if (!result.ok)
+        return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository, sha, context, state: 'unavailable', url: null, detail: (result.stderr || result.stdout || 'consulta ao GitHub falhou').trim().slice(0, 400) };
+    let payload;
+    try {
+        payload = JSON.parse(result.stdout);
+    }
+    catch {
+        return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository, sha, context, state: 'unavailable', url: null, detail: 'GitHub devolveu uma resposta de checks inválida' };
+    }
+    const checks = (payload.check_runs ?? []).filter((check) => check.name === context);
+    if (!checks.length)
+        return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository, sha, context, state: 'missing', url: null, detail: `check ${context} não encontrado no commit` };
+    const check = checks.at(-1);
+    const status = check.status ?? 'unknown';
+    const conclusion = check.conclusion ?? '';
+    const url = check.html_url ?? '';
+    const state = status !== 'completed' ? 'pending' : conclusion === 'success' ? 'success' : 'failure';
+    return { schema: 'ork.ci-status/v1', required: true, ok: state === 'success', provider: 'github', repository, sha, context, state, url: url || null, detail: state === 'success' ? 'CHECK independente verde no GitHub' : `check ${context}: ${status}/${conclusion || 'sem conclusão'}` };
+}
+function executarCi(carregado, threadId) {
+    const verify = (0, verify_1.verificar)(carregado, threadId);
+    const context = carregado.manifesto.ci.context || 'ork-verify';
+    const repository = process.env.GITHUB_REPOSITORY ?? null;
+    return {
+        status: {
+            schema: 'ork.ci-status/v1', required: true, ok: verify.ok, provider: 'github', repository,
+            sha: verify.commit, context, state: verify.ok ? 'success' : 'failure',
+            url: process.env.GITHUB_SERVER_URL && repository && process.env.GITHUB_RUN_ID ? `${process.env.GITHUB_SERVER_URL}/${repository}/actions/runs/${process.env.GITHUB_RUN_ID}` : null,
+            detail: verify.ok ? 'ork verify aprovado no runner independente' : `ork verify reprovou: ${verify.motivos.join(', ')}`,
+        },
+        verify,
+    };
+}
+/**
+ * I-53 (RM-037, P6): o lint no `ci prepare`. Claim nascida sob a regra (com o campo `lint`) que
+ * roda a suite inteira e recusada: o bundle vai para o runner hospedado e reprovaria la, depois de
+ * gastar o tempo todo. O resto so avisa, e o aviso fica no ledger da thread.
+ */
+function lintDoBundle(claims) {
+    const recusas = [], avisos = [];
+    for (const claim of claims) {
+        for (const achado of (0, claim_lint_1.analisarComandos)(claim.verificar)) {
+            const linha = (0, claim_lint_1.linhaDoLintDeClaim)(claim.id, achado);
+            if (achado.regra === 'suite-inteira' && claim.lint !== undefined)
+                recusas.push(linha);
+            else
+                avisos.push(achado.regra === 'suite-inteira' ? `${linha} (claim anterior ao lint: so aviso)` : linha);
+        }
+    }
+    return { recusas, avisos };
+}
+function prepararBundleCi(carregado, threadId, opcoes = {}) {
+    const commands = carregado.manifesto.ci.command
+        ? [{ name: 'ci', command: carregado.manifesto.ci.command }]
+        : (0, verify_2.comandosDoManifesto)(carregado.manifesto).map(({ nome, comando }) => ({ name: nome, command: comando }));
+    const activeClaims = (0, claims_1.lerClaims)(carregado.raiz, threadId).filter((claim) => claim.estado !== 'retirada');
+    const lint = lintDoBundle(activeClaims);
+    if (lint.recusas.length || lint.avisos.length) {
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(carregado.raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.lintDeClaim, { recusas: lint.recusas, avisos: lint.avisos });
+    }
+    for (const aviso of lint.avisos)
+        opcoes.aoAvisar?.(aviso);
+    if (lint.recusas.length) {
+        throw new Error(`claims.lint: o bundle nao foi gerado; retire a claim e registre de novo com o comando focado:\n  ` +
+            lint.recusas.join('\n  '));
+    }
+    const classified = activeClaims.map((claim) => ({
+        claim,
+        reason: motivoDiferimentoCi(claim, carregado.raiz),
+    }));
+    const bundle = {
+        schema: 'ork.ci-bundle/v1',
+        thread: threadId,
+        base: carregado.manifesto.worktree.base_branch,
+        claims: classified.filter((item) => item.reason === null).map((item) => item.claim),
+        deferredClaims: classified
+            .filter((item) => item.reason !== null)
+            .map((item) => ({ id: item.claim.id, reason: item.reason })),
+        commands,
+    };
+    const dir = path.join(carregado.raiz, '.ork-ci');
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, 'bundle.json');
+    fs.writeFileSync(file, JSON.stringify(bundle, null, 2) + '\n', 'utf8');
+    return file;
+}
+function executarBundleCi(carregado, file = '.ork-ci/bundle.json') {
+    const absolute = path.resolve(carregado.raiz, file);
+    const stat = fs.statSync(absolute);
+    if (!stat.isFile() || stat.size > 1024 * 1024)
+        throw new Error('bundle de CI ausente ou acima de 1 MiB');
+    const bundle = JSON.parse(fs.readFileSync(absolute, 'utf8'));
+    if (bundle.schema !== 'ork.ci-bundle/v1' || !/^ork-[a-z0-9-]+$/.test(bundle.thread) || !Array.isArray(bundle.claims) || !Array.isArray(bundle.commands))
+        throw new Error('bundle de CI inválido');
+    // O CI roda o mesmo preparo do `ork verify` local (I-54), uma vez e antes das claims: a claim
+    // que passa na maquina de quem entrega passa aqui pelo mesmo caminho. Como no verify, o
+    // preparo nao e condicao de claim; ele so deixa a compilacao pronta e sai no resultado.
+    const comandoDoPreparo = carregado.manifesto.verify.preparo;
+    const preparo = comandoDoPreparo
+        ? (0, verify_2.executar)('preparo', comandoDoPreparo, carregado.raiz, (0, verify_2.prazoDoComando)(carregado.manifesto, 'preparo'))
+        : null;
+    const claims = bundle.claims.map((claim) => (0, verify_2.verificarClaim)(claim, carregado.raiz));
+    const commands = bundle.commands.map((item) => (0, verify_2.executar)(item.name, item.command, carregado.raiz));
+    const ok = claims.every((item) => item.verificado || item.motivo === 'claims.unverifiable') && commands.every((item) => item.ok);
+    return { schema: 'ork.ci-run/v1', ok, thread: bundle.thread, commit: (0, verify_2.commitReal)(carregado.raiz), preparo, claims, commands };
+}

package/dist/ciclos.js

@@ -85,7 +85,8 @@ function refazerBloco(fases, pausa, pausaSobre) {
  * Funde os blocos que conduzem GOAL e PLAN num bloco unico.
  *
  * Idempotente: em `#Default`, `#Maestro` e `#Auto` o GOAL e o PLAN ja vivem no mesmo
- * bloco e nada muda. Em `#Look` e `#Ork` a fusao economiza exatamente uma pausa.
+ * bloco e nada muda. Em `#Classic`, que abre GOAL e PLAN em blocos separados, a fusao
+ * economiza exatamente uma pausa.
  */
 function fundirGoalPlan(blocos) {
     const envolvidos = blocos.filter((b) => b.fases.includes('GOAL') || b.fases.includes('PLAN'));

package/dist/claim-lint.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * I-53 (RM-037, P6): o lint do comando de claim.
+ *
+ * A claim C48 foi para o bundle rodando a suite inteira do npm e derrubou 33m57s de CI no runner
+ * hospedado. O conhecimento existia; faltava a regra no lugar certo. Ela mora aqui, pura e sem
+ * disco, e e lida em dois pontos com severidades diferentes (D14 do PLAN da I-37):
+ *
+ *   regra                        `claims add`   `ci prepare`
+ *   (a) suite inteira do npm     avisa          RECUSA (so em claim nascida sob a regra)
+ *   (b1) SHA intermediario       avisa          avisa
+ *   (b2) contagem de commits     avisa          avisa
+ *
+ * Toda claim nova nasce com o campo `lint` (vazio quando nada casou). E ele que separa a claim
+ * nascida sob a regra da claim antiga: a antiga so recebe aviso, porque corrigir claim de thread
+ * alheia e mexer em estado de quem nao pediu (D16). Nada de data de corte no codigo.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analisarComando = analisarComando;
+exports.analisarComandos = analisarComandos;
+exports.linhaDoLintDeClaim = linhaDoLintDeClaim;
+const CORRECAO = {
+    'suite-inteira': 'use `npm --prefix core run test:ci` (a suite hermetica) ou `node --test` no arquivo do teste',
+    'sha-intermediario': 'ancore na base (`git diff "$(git merge-base origin/main HEAD)" HEAD`) ou prove ancestralidade com `git merge-base --is-ancestor <sha> HEAD`',
+    'contagem-de-commits': 'use `git merge-base --is-ancestor <commit> HEAD`: contagem de commits quebra com rebase e merge',
+};
+/**
+ * (a) `npm [--prefix <dir>] [run] test` sem subcomando (`test:ci` nao casa) e sem arquivos
+ * nomeados depois de `--` (o comando que nomeia `.test.ts`/`.js` depois de `--` e focado).
+ */
+const SUITE_INTEIRA = /\bnpm\s+(?:(?:--prefix|-C)\s+\S+\s+)?(?:run\s+|run-script\s+)?test(?![\w:.-])(?!\s+--\s+\S*\.test\.(?:ts|js|mjs|cjs|tsx)\b)/;
+/** (b1) Hash de 7 a 40 hex com letra e digito, em comando que cita `git`. */
+const HASH = /\b[0-9a-f]{7,40}\b/g;
+const SO_ANCESTRALIDADE = /merge-base\s+--is-ancestor\s+\S+\s+\S+/g;
+/** (b2) Contagem de commits comparada a um numero. */
+const CONTAGEM = /rev-list\s+(?:[^|;&]*\s)?--count\b|\bgit\s+log\b[^|;&]*\|\s*wc\s+-l\b/;
+const COMPARACAO = /-(?:eq|ne|gt|lt|ge|le)\s+['"]?\d|[^=!<>]==?\s*['"]?\d|grep\s+-(?:q?x|xq)\s+['"]?\d/;
+function analisarComando(comando) {
+    const achados = [];
+    const suite = SUITE_INTEIRA.exec(comando);
+    if (suite)
+        achados.push({ regra: 'suite-inteira', trecho: suite[0].trim(), correcao: CORRECAO['suite-inteira'] });
+    if (/\bgit\b/.test(comando)) {
+        const semAncestralidade = comando.replace(SO_ANCESTRALIDADE, ' ');
+        const hash = [...semAncestralidade.matchAll(HASH)].map((m) => m[0]).find((t) => /\d/.test(t) && /[a-f]/.test(t));
+        if (hash)
+            achados.push({ regra: 'sha-intermediario', trecho: hash, correcao: CORRECAO['sha-intermediario'] });
+    }
+    const contagem = CONTAGEM.exec(comando);
+    if (contagem && COMPARACAO.test(comando)) {
+        achados.push({ regra: 'contagem-de-commits', trecho: contagem[0].trim(), correcao: CORRECAO['contagem-de-commits'] });
+    }
+    return achados;
+}
+/** O lint de todos os comandos de uma claim, na ordem. */
+function analisarComandos(comandos) {
+    return comandos.flatMap(analisarComando);
+}
+/** Uma linha por achado, para o terminal e para o ledger. */
+function linhaDoLintDeClaim(claimId, a) {
+    const nome = { 'suite-inteira': 'roda a suite inteira', 'sha-intermediario': 'fixa um SHA intermediario',
+        'contagem-de-commits': 'compara contagem de commits' }[a.regra];
+    return `${claimId} ${nome} (${a.trecho}); ${a.correcao}`;
+}

package/dist/claims.js

@@ -44,6 +44,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARQUIVO_DONEWHEN = void 0;
 exports.caminhoClaims = caminhoClaims;
 exports.lerClaims = lerClaims;
 exports.proximoIdDeClaim = proximoIdDeClaim;
@@ -51,6 +52,7 @@ exports.ehAlegacaoNegativa = ehAlegacaoNegativa;
 exports.montarClaim = montarClaim;
 exports.gravarClaim = gravarClaim;
 exports.adicionarClaim = adicionarClaim;
+exports.registrarCriteriosDePronto = registrarCriteriosDePronto;
 exports.exigirClaim = exigirClaim;
 exports.anexarComando = anexarComando;
 exports.retirarClaim = retirarClaim;
@@ -58,8 +60,11 @@ exports.carimbarEstado = carimbarEstado;
 exports.tabelaDeClaims = tabelaDeClaims;
 const path = __importStar(require("node:path"));
 const ledger_1 = require("./ledger");
+const manifest_1 = require("./manifest");
+const prova_minima_1 = require("./prova-minima");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const claim_lint_1 = require("./claim-lint");
 /** Caminho do `claims.jsonl` da thread (append-only, como o ledger). */
 function caminhoClaims(raiz, threadId) {
     return path.join((0, thread_1.dirThread)(raiz, threadId), 'claims.jsonl');
@@ -117,15 +122,24 @@ function montarClaim(entrada) {
         verificar,
         criadoEm: (0, util_1.agora)(),
         estado: verificar.length > 0 ? 'pendente' : 'nao-verificavel',
+        ...(entrada.origem ? { origem: entrada.origem } : {}),
+        // I-53 (RM-037, P6): a mesma regra para CLI, MCP, canarios e auditor, porque todos passam aqui.
+        lint: (0, claim_lint_1.analisarComandos)(verificar),
     };
 }
 /** Grava uma claim no `claims.jsonl` (append-only). */
 function gravarClaim(raiz, claim) {
     (0, util_1.anexarJsonl)(caminhoClaims(raiz, claim.thread), claim);
 }
+/** I-42 (D5): a suite inteira do manifesto, que um ciclo sem CHECK nao roda como prova. */
+function comandoDeTesteDoManifesto(raiz) {
+    return (0, manifest_1.carregarManifesto)(raiz)?.manifesto.verify.test;
+}
 /** `ork claims add`: registra a alegacao e a lista no `thread.json` e no ledger. */
 function adicionarClaim(raiz, threadId, opcoes) {
     const thread = (0, thread_1.lerThread)(raiz, threadId);
+    if ((0, prova_minima_1.cicloSemCheck)(thread))
+        (0, prova_minima_1.validarProvaSemCheck)(opcoes.verificar ?? [], comandoDeTesteDoManifesto(raiz));
     const existentes = lerClaims(raiz, threadId);
     const claim = montarClaim({
         id: proximoIdDeClaim(existentes),
@@ -134,6 +148,7 @@ function adicionarClaim(raiz, threadId, opcoes) {
         arquivo: opcoes.arquivo,
         alegacao: opcoes.alegacao,
         verificar: opcoes.verificar,
+        origem: opcoes.origem,
     });
     const negativa = claim.negativa;
     const verificar = claim.verificar;
@@ -148,9 +163,49 @@ function adicionarClaim(raiz, threadId, opcoes) {
         negativa,
         verificar,
         estado: claim.estado,
+        ...(claim.lint?.length ? { lint: claim.lint.map((a) => a.regra) } : {}),
     });
     return claim;
 }
+/** Prefixo do arquivo das claims de criterio, para o veredito dizer de onde veio. */
+exports.ARQUIVO_DONEWHEN = 'thread.json#doneWhen';
+/**
+ * Registra os criterios de pronto da thread como CLAIMS do nucleo (I-43, D4, viga b).
+ *
+ * E o que torna `doneWhen` executavel sem criar uma segunda maquina de rodar comando.
+ * A alternativa rejeitada em D4 era um executor proprio em `donewhen.ts`, que
+ * duplicaria timeout, captura de saida, codigo de retorno e registro de evidencia,
+ * tudo ja resolvido em claims e verify. Duas maquinas de executar comando divergem, e
+ * a divergencia aparece como criterio que passa num lugar e falha no outro.
+ *
+ * A claim carrega o TEXTO do criterio na alegacao, e e por isso que o veredito do
+ * `ork verify` o nomeia sem precisar de nenhum campo extra: quando ela reprova, o
+ * relatorio ja diz qual criterio falhou.
+ *
+ * IDEMPOTENTE: registrar de novo nao duplica claim. `ork verify` roda em toda fase, e
+ * uma claim por criterio POR RODADA transformaria a lista num acumulador.
+ */
+function registrarCriteriosDePronto(raiz, threadId) {
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    const criterios = thread.doneWhen ?? [];
+    if (criterios.length === 0)
+        return [];
+    const existentes = lerClaims(raiz, threadId);
+    const novas = [];
+    for (const { criterio, comando } of criterios) {
+        const alegacao = `criterio de pronto: ${criterio.trim()}`;
+        const ja = existentes.find((c) => c.origem === 'nucleo.doneWhen' && c.alegacao === alegacao);
+        if (ja)
+            continue;
+        novas.push(adicionarClaim(raiz, threadId, {
+            arquivo: exports.ARQUIVO_DONEWHEN,
+            alegacao,
+            verificar: [comando],
+            origem: 'nucleo.doneWhen',
+        }));
+    }
+    return novas;
+}
 /** Acha a claim pelo id, com erro acionavel quando ela nao existe. */
 function exigirClaim(raiz, threadId, claimId) {
     const claim = lerClaims(raiz, threadId).find((c) => c.id === claimId);
@@ -167,10 +222,15 @@ function exigirClaim(raiz, threadId, claimId) {
  */
 function anexarComando(raiz, threadId, claimId, comando) {
     const claim = exigirClaim(raiz, threadId, claimId);
+    if ((0, prova_minima_1.cicloSemCheck)((0, thread_1.lerThread)(raiz, threadId))) {
+        (0, prova_minima_1.validarProvaSemCheck)([...claim.verificar, comando], comandoDeTesteDoManifesto(raiz));
+    }
     const atualizada = {
         ...claim,
         verificar: [...claim.verificar, comando],
         estado: 'pendente',
+        // I-53: claim nascida sob a regra refaz o lint; a antiga continua sem o campo (so aviso).
+        ...(claim.lint ? { lint: (0, claim_lint_1.analisarComandos)([...claim.verificar, comando]) } : {}),
     };
     gravarClaim(raiz, atualizada);
     (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.claimRegistrada, {

package/dist/company-brain-capture.js

@@ -0,0 +1,195 @@
+"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.capture = capture;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const company_brain_contract_1 = require("./company-brain-contract");
+const company_brain_client_1 = require("./company-brain-client");
+const company_brain_journal_1 = require("./company-brain-journal");
+const company_brain_source_1 = require("./company-brain-source");
+function capture(scope, dir, catalog, ledger, transport, fault = () => { }, journal = []) {
+    const file = path.join(dir, 'cursor.json');
+    fs.mkdirSync(dir, { recursive: true });
+    return (0, company_brain_journal_1.withProcessLock)(path.join(dir, 'capture.lock'), 'brain.capture.busy', () => {
+        let cursor = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : { schema: 'ork.brain-cursor/v2', scope,
+            offset: 0, prefixHash: (0, company_brain_journal_1.bytesHash)(''), versions: {}, pending: {}, confirmed: {} };
+        // Preserve the single outstanding v1 outbox item and its already-spent attempts.
+        const legacy = cursor;
+        if (legacy.schema === 'ork.brain-cursor/v1') {
+            const p = legacy.pending;
+            cursor = { ...legacy, schema: 'ork.brain-cursor/v2', pending: {}, confirmed: {} };
+            if (p)
+                cursor.pending[p.event.aggregate_id] = { event: p.event, attempts: p.attempts, error: p.error,
+                    ...(p.next.offset > cursor.offset ? { end: p.next.offset } : { version: p.next.versions[p.event.aggregate_id] }) };
+        }
+        if (cursor.schema !== 'ork.brain-cursor/v2' || JSON.stringify(cursor.scope) !== JSON.stringify(scope) ||
+            !Number.isSafeInteger(cursor.offset) || cursor.offset < 0 || cursor.offset > ledger.length ||
+            (0, company_brain_journal_1.bytesHash)(ledger.subarray(0, cursor.offset)) !== cursor.prefixHash)
+            throw Error('brain.cursor.source-conflict');
+        const source = (0, company_brain_source_1.readCycle)(ledger, scope, cursor.offset);
+        let received = 0;
+        const errors = {};
+        // A migration may have materialized the current snapshot before this local
+        // cursor existed. Read the authenticated aggregate head and continue from
+        // its monotonic sequence; never guess from a local migration plan.
+        for (const entity of (0, company_brain_source_1.portfolioEntities)(catalog, scope)) {
+            if (cursor.versions[entity.id] || cursor.pending[entity.id])
+                continue;
+            let response;
+            try {
+                response = transport({ schema: company_brain_client_1.BRAIN_API, operation: 'head', payload: { tenant_id: scope.tenant, id: entity.id } });
+            }
+            catch {
+                response = { state: 'unavailable' };
+            }
+            if (response.state === 'unknown')
+                continue;
+            if (response.state !== 'ok') {
+                if (['forbidden', 'withheld', 'conflict'].includes(response.state))
+                    errors[entity.id] = 'brain.capture.head-unavailable';
+                continue;
+            }
+            const head = response;
+            if (!Number.isSafeInteger(head.sequence) || head.sequence < 1 || typeof head.active !== 'boolean' ||
+                (head.active && (!Number.isSafeInteger(head.source_version) || head.source_version < 1 ||
+                    typeof head.source_hash !== 'string' || !/^[a-f0-9]{64}$/.test(head.source_hash)))) {
+                errors[entity.id] = 'brain.capture.head-invalid';
+                continue;
+            }
+            if (!head.active) {
+                cursor.versions[entity.id] = { version: 0, hash: '', sequence: head.sequence };
+                continue;
+            }
+            if (head.source_version > entity.version) {
+                errors[entity.id] = 'brain.source.version-conflict';
+                continue;
+            }
+            cursor.versions[entity.id] = { version: head.source_version, hash: head.source_hash, sequence: head.sequence };
+        }
+        const flush = (aggregate) => {
+            const pending = cursor.pending[aggregate];
+            if (!pending)
+                return true;
+            const event = (0, company_brain_contract_1.validateContract)(pending.event);
+            while (pending.attempts < 3) {
+                pending.attempts++;
+                (0, company_brain_journal_1.atomicJson)(file, cursor);
+                fault('attempt');
+                let response;
+                try {
+                    response = transport({ schema: company_brain_client_1.BRAIN_API, operation: 'ingest', payload: event });
+                }
+                catch {
+                    response = { state: 'unavailable' };
+                }
+                try {
+                    if (response.state !== 'ok')
+                        throw Error('brain.capture.unconfirmed');
+                    const receipt = (0, company_brain_contract_1.validateContract)(response.receipt);
+                    const indexed = (0, company_brain_contract_1.validateContract)(response.indexed);
+                    for (const [r, stage] of [[receipt, 'materialized'], [indexed, 'retrievable']]) {
+                        if (r.schema !== 'orkmind.company-brain-receipt/v1' || r.tenant_id !== scope.tenant || r.event_id !== event.id || r.stage !== stage || r.result !== 'ok' ||
+                            r.materialized_version !== (event.payload?.version ?? r.materialized_version))
+                            throw Error('brain.receipt.invalid');
+                    }
+                    fault('remote-receipt');
+                    (0, company_brain_journal_1.durableAppend)(path.join(dir, 'receipts.jsonl'), { event_id: event.id, receipt, indexed });
+                    if (pending.version)
+                        cursor.versions[aggregate] = pending.version;
+                    if (pending.end !== undefined)
+                        cursor.confirmed[String(pending.end)] = true;
+                    delete cursor.pending[aggregate];
+                    (0, company_brain_journal_1.atomicJson)(file, cursor);
+                    fault('cursor');
+                    received++;
+                    return true;
+                }
+                catch (error) {
+                    if (error instanceof Error && error.message === 'injected-crash')
+                        throw error;
+                    pending.error = 'brain.capture.unconfirmed';
+                    (0, company_brain_journal_1.atomicJson)(file, cursor);
+                    if (['conflict', 'forbidden', 'withheld'].includes(response.state))
+                        break;
+                }
+            }
+            errors[aggregate] = 'brain.capture.dead-letter';
+            return false;
+        };
+        for (const aggregate of Object.keys(cursor.pending))
+            flush(aggregate);
+        const enqueue = (pending) => {
+            cursor.pending[pending.event.aggregate_id] = pending;
+            (0, company_brain_journal_1.atomicJson)(file, cursor);
+            fault('outbox');
+            return flush(pending.event.aggregate_id);
+        };
+        for (const entity of (0, company_brain_source_1.portfolioHistory)(catalog, scope, journal)) {
+            if (errors[entity.id] || cursor.pending[entity.id])
+                continue;
+            const old = cursor.versions[entity.id];
+            if (old && entity.version < old.version)
+                continue;
+            if (old?.version === entity.version) {
+                if (old.hash !== entity.source.source_hash)
+                    errors[entity.id] = 'brain.source.version-conflict';
+                continue;
+            }
+            if (old && entity.version !== old.version + 1) {
+                errors[entity.id] = 'brain.source.version-gap';
+                continue;
+            }
+            const sequence = (old?.sequence ?? 0) + 1;
+            enqueue({ event: (0, company_brain_source_1.entityEvent)(entity, sequence), version: { version: entity.version, hash: entity.source.source_hash, sequence }, attempts: 0, error: null });
+        }
+        for (const record of source.records) {
+            if (!record.event || cursor.confirmed[String(record.end)] || cursor.pending[record.event.aggregate_id])
+                continue;
+            enqueue({ event: record.event, end: record.end, attempts: 0, error: null });
+        }
+        // Independent aggregates can confirm out of order; the ledger watermark cannot.
+        for (const record of source.records) {
+            if (record.event && !cursor.confirmed[String(record.end)])
+                break;
+            cursor.offset = record.end;
+            cursor.prefixHash = record.prefixHash;
+            delete cursor.confirmed[String(record.end)];
+        }
+        (0, company_brain_journal_1.atomicJson)(file, cursor);
+        return { state: Object.keys(errors).length ? 'unavailable' : 'ok', received, offset: cursor.offset, partial: source.partial,
+            ...(Object.keys(errors).length ? { error: 'brain.capture.aggregate-blocked', errors } : {}) };
+    });
+}