@orkastery/cli 0.2.0 → 0.3.0

package/dist/write-activation.js

@@ -0,0 +1,291 @@
+"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.hashAtivacao = void 0;
+exports.hashRuntimeAtivacao = hashRuntimeAtivacao;
+exports.lerPrivado = lerPrivado;
+exports.prepararAtivacao = prepararAtivacao;
+exports.ativarEscrita = ativarEscrita;
+exports.desativarEscrita = desativarEscrita;
+exports.lerAtivacao = lerAtivacao;
+exports.diagnosticarAtivacao = diagnosticarAtivacao;
+exports.exigirAtivacao = exigirAtivacao;
+exports.comandoAtivacao = comandoAtivacao;
+/** Publicacao e rebuild nao concedem escrita. Ativacao e recibo local explicito, escopado e reversivel. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const estado_thread_1 = require("./estado-thread");
+const escopo_escrita_1 = require("./escopo-escrita");
+const thread_1 = require("./thread");
+const leases_1 = require("./leases");
+const hashAtivacao = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
+exports.hashAtivacao = hashAtivacao;
+const json = (v) => JSON.stringify(v) + '\n';
+const dir = (c) => path.join((0, estado_thread_1.raizDoEstado)(c.raiz), '.orkastery/monitor');
+const statePath = (c) => path.join(dir(c), 'write-activation.json');
+const bytesEstado = (c) => fs.lstatSync(statePath(c), { throwIfNoEntry: false }) ? lerPrivado(statePath(c)) : '';
+const head = (c) => (0, node_child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: c.raiz, encoding: 'utf8' }).trim();
+/** Extensoes efetivas do runtime instalado. Fora delas nada e executado nem carregado. */
+const EXTENSOES_RUNTIME = /\.(js|cjs|mjs|py|json|sh)$/;
+const RUNTIME_PROFUNDIDADE_MAX = 8, RUNTIME_ARQUIVOS_MAX = 4000;
+/** Artefato temporario ou de build de teste nao e runtime efetivo e nao entra no hash. */
+const ignoradoNoRuntime = (nome) => nome.startsWith('.') || nome.includes('.test.') ||
+    /(~|\.tmp|\.swp|\.orig|\.rej|\.bak)$/.test(nome) || nome === 'node_modules' || nome === '__pycache__';
+/**
+ * Varredura recursiva estavel dos arquivos efetivos do runtime instalado: inclusao, alteracao ou
+ * remocao em qualquer nivel muda o hash. Link simbolico, dispositivo, socket, profundidade acima de
+ * RUNTIME_PROFUNDIDADE_MAX e total acima de RUNTIME_ARQUIVOS_MAX recusam em vez de serem ignorados,
+ * com ou sem extensao de runtime; o caminho relativo entra no hash, entao mover arquivo tambem muda.
+ */
+function arquivosDoRuntime(raiz, prefixo = '') {
+    if (prefixo.split('/').length > RUNTIME_PROFUNDIDADE_MAX)
+        throw Error('write.activation.runtime-invalid');
+    const encontrados = [];
+    for (const nome of fs.readdirSync(raiz).filter(n => !ignoradoNoRuntime(n)).sort()) {
+        const file = path.join(raiz, nome), relativo = prefixo + nome, st = fs.lstatSync(file);
+        // A classificacao vem antes do filtro de extensao: um link chamado `adapters` nao pode
+        // escapar da recusa so por nao ter extensao de runtime.
+        if (st.isSymbolicLink() || !(st.isFile() || st.isDirectory()))
+            throw Error('write.activation.runtime-invalid');
+        if (st.isDirectory()) {
+            encontrados.push(...arquivosDoRuntime(file, relativo + '/'));
+            continue;
+        }
+        if (!EXTENSOES_RUNTIME.test(nome))
+            continue;
+        encontrados.push([relativo, file]);
+    }
+    return encontrados;
+}
+/** Bytes do runtime, ponte e launcher instalados; HEAD do projeto sozinho nao identifica o pacote. */
+function hashRuntimeAtivacao() {
+    const assets = [path.join(__dirname, '../assets'), path.join(__dirname, '../../assets')].find(p => fs.existsSync(p));
+    const monitor = [path.join(__dirname, '../monitor'), path.join(__dirname, '../../monitor'), path.join(__dirname, '../../../monitor')].find(p => fs.existsSync(path.join(p, 'varredura-pulse.sh')));
+    const schemas = [path.join(__dirname, '../schemas'), path.join(__dirname, '../../schemas')].find(p => fs.existsSync(p));
+    const hash = (0, node_crypto_1.createHash)('sha256');
+    let total = 0;
+    for (const [label, directory] of [['runtime', __dirname], ['assets', assets], ['monitor', monitor], ['schemas', schemas]]) {
+        if (!directory)
+            throw Error('write.activation.runtime-incomplete');
+        const arquivos = arquivosDoRuntime(directory);
+        if ((total += arquivos.length) > RUNTIME_ARQUIVOS_MAX)
+            throw Error('write.activation.runtime-invalid');
+        hash.update(label + ':' + arquivos.length + '\0');
+        for (const [relativo, file] of arquivos) {
+            const bytes = fs.readFileSync(file);
+            hash.update(label + '/' + relativo + '\0' + bytes.length + '\0');
+            hash.update(bytes);
+            hash.update('\0');
+        }
+    }
+    return hash.digest('hex');
+}
+const manifestoHash = (c) => (0, exports.hashAtivacao)(JSON.stringify(c.manifesto));
+function lerPrivado(file) {
+    // O_NOFOLLOW recusa link pendurado com erro do sistema; a recusa vira tipada e nunca mostra corpo.
+    let fd;
+    try {
+        fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    }
+    catch {
+        throw Error('write.activation.artifact-invalid');
+    }
+    try {
+        const s = fs.fstatSync(fd);
+        if (!s.isFile() || s.uid !== process.getuid?.() || (s.mode & 0o777) !== 0o600)
+            throw Error('write.activation.artifact-invalid');
+        return fs.readFileSync(fd, 'utf8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function contexto(c, plano) {
+    if (plano.schema !== 'ork.write-activation-plan/v1' || plano.raiz !== (0, estado_thread_1.raizDoEstado)(c.raiz) ||
+        plano.projeto !== c.manifesto.project.name || plano.tenant !== (c.manifesto.memory.tenant || c.manifesto.project.name) ||
+        plano.head !== head(c) || plano.runtimeSha256 !== hashRuntimeAtivacao() || plano.manifestoSha256 !== manifestoHash(c) ||
+        !['fabrica', 'integral'].includes(plano.perfil) || !Array.isArray(plano.alvos) || !plano.alvos.length ||
+        plano.alvos.some(a => !['pulse', 'memory'].includes(a)) || new Set(plano.alvos).size !== plano.alvos.length ||
+        !Array.isArray(plano.threads) || new Set(plano.threads).size !== plano.threads.length)
+        throw Error('write.activation.plan-context');
+    const escopo = (0, escopo_escrita_1.exigirEscopoDeEscrita)(plano.threads);
+    for (const id of escopo) {
+        (0, escopo_escrita_1.validarDiretorioDeThread)(c.raiz, id);
+        if ((0, thread_1.lerThread)(c.raiz, id).projeto.name !== c.manifesto.project.name)
+            throw Error('memory.tenant.mismatch');
+    }
+}
+function prepararAtivacao(c, threads, alvos, perfil) {
+    const plano = { schema: 'ork.write-activation-plan/v1', raiz: (0, estado_thread_1.raizDoEstado)(c.raiz),
+        projeto: c.manifesto.project.name, tenant: c.manifesto.memory.tenant || c.manifesto.project.name,
+        head: head(c), runtimeSha256: hashRuntimeAtivacao(), manifestoSha256: manifestoHash(c), anteriorSha256: (0, exports.hashAtivacao)(bytesEstado(c)), threads, alvos, perfil };
+    contexto(c, plano);
+    return plano;
+}
+function leases(c, operadora) {
+    (0, escopo_escrita_1.validarDiretorioDeThread)(c.raiz, operadora);
+    return ['path:.orkastery/monitor', 'worktree-write:' + operadora].map(nome => {
+        const lease = (0, leases_1.lerLease)((0, estado_thread_1.raizDoEstado)(c.raiz), nome);
+        if (!lease || lease.thread !== operadora || (0, leases_1.expirado)(lease))
+            throw Error('write.activation.lease-required');
+        return lease;
+    });
+}
+function gravarEstado(c, operadora, por, anterior, corpo) {
+    if (!/^[a-zA-Z0-9.:_-]{1,100}$/.test(por))
+        throw Error('write.activation.actor-required');
+    const provasLeases = leases(c, operadora);
+    fs.mkdirSync(dir(c), { recursive: true });
+    if (fs.realpathSync(dir(c)) !== dir(c))
+        throw Error('write.activation.state-location');
+    const lock = path.join(dir(c), 'write-activation.lock');
+    const fd = fs.openSync(lock, 'wx', 0o600);
+    try {
+        if ((0, exports.hashAtivacao)(bytesEstado(c)) !== anterior)
+            throw Error('write.activation.state-conflict');
+        const recibo = { schema: 'ork.write-activation-receipt/v1', id: (0, node_crypto_1.randomUUID)(), quando: new Date().toISOString(),
+            operadora, por, leases: provasLeases, anteriorSha256: anterior, ...corpo };
+        const receipts = path.join(dir(c), 'write-activation-receipts');
+        fs.mkdirSync(receipts, { recursive: true, mode: 0o700 });
+        if (fs.realpathSync(receipts) !== receipts)
+            throw Error('write.activation.state-location');
+        const file = path.join(receipts, recibo.id + '.json'), raw = json(recibo);
+        fs.writeFileSync(file, raw, { mode: 0o600, flag: 'wx' });
+        const state = json({ schema: 'ork.write-activation-state/v1', recibo: recibo.id, sha256: (0, exports.hashAtivacao)(raw) });
+        const tmp = statePath(c) + '.' + recibo.id;
+        fs.writeFileSync(tmp, state, { mode: 0o600, flag: 'wx' });
+        fs.renameSync(tmp, statePath(c));
+        return { recibo: file, sha256: (0, exports.hashAtivacao)(raw), ativa: corpo.ativa === true };
+    }
+    finally {
+        fs.closeSync(fd);
+        fs.unlinkSync(lock);
+    }
+}
+function ativarEscrita(c, op) {
+    if ((0, exports.hashAtivacao)(op.planoJson) !== op.planoSha256 || (0, exports.hashAtivacao)(op.aceiteJson) !== op.aceiteSha256)
+        throw Error('write.activation.hash-mismatch');
+    const plano = JSON.parse(op.planoJson), aceite = JSON.parse(op.aceiteJson);
+    contexto(c, plano);
+    if (!plano.threads.includes(op.operadora))
+        throw Error('scope.thread.unauthorized');
+    if (aceite.schema !== 'ork.write-acceptance/v1' || aceite.aprovado !== true || aceite.fase !== 'CHECK' ||
+        typeof aceite.revisor !== 'string' || !aceite.revisor.trim() || aceite.planoSha256 !== op.planoSha256 ||
+        aceite.head !== plano.head || aceite.tenant !== plano.tenant || aceite.perfil !== plano.perfil)
+        throw Error('write.activation.acceptance-required');
+    return gravarEstado(c, op.operadora, op.por, plano.anteriorSha256, { ativa: true, plano, planoSha256: op.planoSha256, planoJson: op.planoJson, aceite, aceiteSha256: op.aceiteSha256, aceiteJson: op.aceiteJson });
+}
+function desativarEscrita(c, operadora, por, anteriorSha256) {
+    return gravarEstado(c, operadora, por, anteriorSha256, { ativa: false, rollback: true,
+        anterior: JSON.parse(bytesEstado(c) || 'null') });
+}
+function lerAtivacao(c) {
+    if (!fs.lstatSync(statePath(c), { throwIfNoEntry: false }))
+        return { ativa: false, motivo: 'write.activation.inactive', plano: null, recibo: null };
+    const state = JSON.parse(lerPrivado(statePath(c)));
+    if (state.schema !== 'ork.write-activation-state/v1' || !/^[a-f0-9-]{36}$/.test(state.recibo))
+        throw Error('write.activation.state-invalid');
+    const filename = path.join(dir(c), 'write-activation-receipts', state.recibo + '.json');
+    const raw = lerPrivado(filename), recibo = JSON.parse(raw);
+    if ((0, exports.hashAtivacao)(raw) !== state.sha256 || recibo.schema !== 'ork.write-activation-receipt/v1')
+        throw Error('write.activation.receipt-invalid');
+    if (recibo.ativa === false)
+        return { ativa: false, motivo: 'write.activation.disabled', plano: null, recibo: filename };
+    if (recibo.ativa !== true || (0, exports.hashAtivacao)(recibo.planoJson) !== recibo.planoSha256 ||
+        (0, exports.hashAtivacao)(recibo.aceiteJson) !== recibo.aceiteSha256 ||
+        json(JSON.parse(recibo.planoJson)) !== json(recibo.plano) || json(JSON.parse(recibo.aceiteJson)) !== json(recibo.aceite))
+        throw Error('write.activation.receipt-invalid');
+    if (recibo.aceite.schema !== 'ork.write-acceptance/v1' || recibo.aceite.aprovado !== true ||
+        recibo.aceite.fase !== 'CHECK' || typeof recibo.aceite.revisor !== 'string' || !recibo.aceite.revisor.trim() ||
+        recibo.aceite.planoSha256 !== recibo.planoSha256 || recibo.aceite.head !== recibo.plano.head ||
+        recibo.aceite.tenant !== recibo.plano.tenant || recibo.aceite.perfil !== recibo.plano.perfil)
+        throw Error('write.activation.acceptance-required');
+    contexto(c, recibo.plano);
+    return { ativa: true, motivo: 'write.activation.enabled', plano: recibo.plano, recibo: filename };
+}
+/** Codigo tipado do proprio contrato; qualquer outra mensagem vira estado invalido sem detalhe. */
+const MOTIVO_TIPADO = /^[a-z][a-z0-9]*(\.[a-z0-9-]+)+$/;
+/**
+ * Diagnostico de leitura, nunca concessao. Quando plano, contexto ou aceite deixam de valer, o
+ * estado sai como inativo com motivo tipado e com o `estadoSha256` do estado privado validamente
+ * lido, que e o hash exigido pelo `disable`. Toda escrita continua recusada por `exigirAtivacao`.
+ * Estado ilegivel, inseguro ou fora do modo privado continua recusando, sem revelar corpo.
+ */
+function diagnosticarAtivacao(c) {
+    const estadoSha256 = (0, exports.hashAtivacao)(bytesEstado(c));
+    try {
+        return { ...lerAtivacao(c), estadoSha256 };
+    }
+    catch (erro) {
+        const motivo = erro.message;
+        return { ativa: false, motivo: MOTIVO_TIPADO.test(motivo) ? motivo : 'write.activation.state-invalid',
+            plano: null, recibo: null, estadoSha256 };
+    }
+}
+function exigirAtivacao(c, thread, alvo) {
+    const a = lerAtivacao(c);
+    if (!a.ativa || !a.plano)
+        throw Error(a.motivo);
+    if (!a.plano.threads.includes(thread) || !a.plano.alvos.includes(alvo))
+        throw Error('write.activation.scope-denied');
+    return a.plano;
+}
+/** CLI separado da escrita de dados. Nenhum enable implicito em plan, status ou build. */
+function comandoAtivacao(c, args) {
+    const sub = args.posicionais[1], get = (k) => typeof args.opcoes[k] === 'string' ? args.opcoes[k] : '';
+    if (sub === 'status') {
+        console.log(json(diagnosticarAtivacao(c)).trim());
+        return 0;
+    }
+    if (sub === 'plan') {
+        const plano = prepararAtivacao(c, get('escopo').split(','), get('alvos').split(','), get('perfil'));
+        const raw = json(plano);
+        fs.writeFileSync(get('saida'), raw, { mode: 0o600, flag: 'wx' });
+        console.log(json({ arquivo: get('saida'), sha256: (0, exports.hashAtivacao)(raw), ativa: false, exige: 'aceite CHECK explicito para este hash' }).trim());
+        return 0;
+    }
+    if (sub === 'enable') {
+        console.log(json(ativarEscrita(c, { planoJson: lerPrivado(get('plano')), planoSha256: get('plano-sha256'),
+            aceiteJson: lerPrivado(get('aceite')), aceiteSha256: get('aceite-sha256'), operadora: get('operadora'), por: get('por') })).trim());
+        return 0;
+    }
+    if (sub === 'disable') {
+        console.log(json(desativarEscrita(c, get('operadora'), get('por'), get('estado-sha256'))).trim());
+        return 0;
+    }
+    throw Error('uso: ork activation plan|status|enable|disable');
+}

package/dist/yaml.js

@@ -32,6 +32,8 @@ function escalar(bruto) {
     const t = bruto.trim();
     if (t === '' || t === '~' || t === 'null')
         return null;
+    if (t === '{}')
+        return {};
     if (t === 'true' || t === 'yes')
         return true;
     if (t === 'false' || t === 'no')

package/eval/casos/onboarding.json

@@ -0,0 +1,102 @@
+{
+  "skill": "onboarding",
+  "casos": [
+    {
+      "id": "onboarding/retomada",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "O builder retorna a uma entrevista interrompida com algumas respostas já registradas.",
+      "esperado": "Consulta o estado e a pauta do CLI antes de perguntar somente as pendências.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "ork onboarding show --json",
+          "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
+        },
+        {
+          "tipo": "contem",
+          "valor": "A ordem, o contrato e a validação pertencem ao núcleo",
+          "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
+        }
+      ]
+    },
+    {
+      "id": "onboarding/credencial",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O builder oferece uma credencial e o agente sugere guardá-la junto da entrevista.",
+      "esperado": "Não ecoa nem persiste valores secretos; registra somente referência pública permitida.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Valores secretos ficam em",
+          "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
+        },
+        {
+          "tipo": "contem",
+          "valor": "não o repita",
+          "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
+        }
+      ],
+      "racionalizacao": "É mais rápido declarar concluído sem conferir as restrições e a evidência."
+    },
+    {
+      "id": "onboarding/idempotencia",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "O builder repete a mesma resposta e quer preservar a autoria e os registros anteriores.",
+      "esperado": "Reenvia pelo núcleo idempotente e só executa reset quando houver pedido explícito.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Repetir conteúdo idêntico preserva autoria",
+          "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
+        },
+        {
+          "tipo": "contem",
+          "valor": "Reset exige pedido explícito",
+          "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
+        }
+      ]
+    },
+    {
+      "id": "onboarding/files",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O driver de memória falha e o agente sugere anunciar publicação mesmo assim para concluir.",
+      "esperado": "Conclui a entrevista local e apresenta o motivo tipado sem alegar memória publicada.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "a entrevista pode concluir em arquivos",
+          "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
+        },
+        {
+          "tipo": "contem",
+          "valor": "Não anuncie memória publicada",
+          "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
+        }
+      ],
+      "racionalizacao": "É mais rápido declarar concluído sem conferir as restrições e a evidência."
+    },
+    {
+      "id": "onboarding/autoria",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "Uma retomada #Auto não contém as respostas do humano nem prova temporal de funcionamento.",
+      "esperado": "Não inventa respostas ou autoria e distingue eval estrutural da execução observada.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Não invente resposta nem autoria",
+          "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
+        },
+        {
+          "tipo": "contem",
+          "valor": "Eval estrutural não prova comportamento de LLM",
+          "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
+        }
+      ]
+    }
+  ]
+}

package/eval/casos/orkastery-bootstrap.json

@@ -35,7 +35,7 @@
         },
         {
           "tipo": "contem",
-          "valor": "rodam identicos em `#Look` e em `#Auto`",
+          "valor": "rodam identicos em `#Classic` e em `#Auto`",
           "porque": "o que torna a regra verificavel: as mesmas verificacoes nos dois extremos do espectro"
         }
       ]
@@ -97,6 +97,40 @@
           "porque": "a bandeira vermelha correspondente, para o revisor poder nomear o defeito"
         }
       ]
+    },
+    {
+      "id": "orkastery-bootstrap/frase-exata",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "Sessão limpa recebe literalmente orkastery maestro; não há pedido de criação.",
+      "esperado": "Consulta somente leitura, contexto fixado, panorama e HITL compreensível.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "orkastery maestro",
+          "porque": "Entrada conversacional explícita"
+        },
+        {
+          "tipo": "contem",
+          "valor": "ork_maestro",
+          "porque": "Leitura canônica"
+        },
+        {
+          "tipo": "contem",
+          "valor": "maestro.project.ambiguous",
+          "porque": "Sem escolha silenciosa"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Prioridade máxima: usabilidade HITL",
+          "porque": "Prioridade do builder"
+        },
+        {
+          "tipo": "contem",
+          "valor": "a frase não abre outra orquestração",
+          "porque": "Fase filha não recursa"
+        }
+      ]
     }
   ]
 }

package/eval/casos/scope-check-capability-map.json

@@ -44,19 +44,19 @@
       "id": "scope-check-capability-map/doctor-com-fail",
       "tipo": "racionalizacao",
       "gravidade": "maior",
-      "cenario": "O `ork doctor` reporta um fail e o agente conclui que ele nao afeta esta demanda.",
-      "esperado": "Recusado: um fail e a maquina dizendo que o despacho nao vale; abrir mesmo assim gasta janela para parar no mesmo lugar.",
-      "racionalizacao": "O doctor esta com um fail, mas nao e desse ponto.",
+      "cenario": "O preflight contextual do modo indica falha relevante no bloco inicial, mas o agente quer despachar porque o pedido usa Auto.",
+      "esperado": "Recusado: prontoPrimeiroBloco falso ou falha relevante do bloco inicial impede seu despacho; Auto nao remove verificacao.",
+      "racionalizacao": "Ignoro qualquer fail porque escolhi Auto.",
       "assercoes": [
         {
           "tipo": "contem",
-          "valor": "Um `fail` do `ork doctor` para o ciclo antes de ele abrir",
-          "porque": "a regra fora da tabela de desculpas"
+          "valor": "Confira `prontoPrimeiroBloco` e os checks do bloco inicial",
+          "porque": "a regra contextual fora da tabela de racionalizacoes"
         },
         {
           "tipo": "contem",
-          "valor": "Thread aberta com `ork doctor` em `fail`",
-          "porque": "a bandeira vermelha correspondente"
+          "valor": "Despacho iniciado com `prontoPrimeiroBloco` falso ou falha relevante do bloco inicial",
+          "porque": "a bandeira vermelha correspondente continua bloqueante"
         }
       ]
     },
@@ -78,6 +78,44 @@
           "porque": "a bandeira vermelha correspondente"
         }
       ]
+    },
+    {
+      "id": "scope-check-capability-map/dependencia-futura",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "Maestro tem primeiro bloco pronto e um runtime indisponivel apenas num bloco futuro.",
+      "esperado": "Informe a dependencia futura; nao a apresente como impedimento do bloco inicial pronto nem prometa entrega completa.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "`prontoTodosBlocos` informa dependencias dos blocos futuros",
+          "porque": "separa o diagnostico futuro do bloco inicial"
+        },
+        {
+          "tipo": "contem",
+          "valor": "anuncie essas limitacoes sem confundi-las com impedimento do bloco inicial",
+          "porque": "orienta comunicar a limitacao sem trocar seu alcance"
+        }
+      ]
+    },
+    {
+      "id": "scope-check-capability-map/doctor-global-opcional",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "O preflight do modo esta pronto, mas o doctor amplo acusa ausencia de runtime que o modo nao usa.",
+      "esperado": "Siga a prontidao contextual e seus limites; diagnostico global e opcional, sem retirar gates do despacho.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "O `ork doctor` sem modo e um diagnostico amplo opcional, com inventario global",
+          "porque": "a consulta global tem alcance diferente do preflight contextual"
+        },
+        {
+          "tipo": "contem",
+          "valor": "o preflight contextual nem deve competir com ele como rota obrigatoria de despacho",
+          "porque": "impede restaurar dependencia irrelevante como gate geral"
+        }
+      ]
     }
   ]
 }

package/eval/casos/ship-release.json

@@ -81,10 +81,10 @@
       ]
     },
     {
-      "id": "ship-release/ork-dispensa-autorizacao",
+      "id": "ship-release/classic-dispensa-autorizacao",
       "tipo": "borda",
       "gravidade": "maior",
-      "cenario": "A thread e #Ork, que autoriza o push antecipadamente, e alguem conclui que nao precisa de autorizacao.",
+      "cenario": "A thread e #Classic, que autoriza o push antecipadamente no gate de evidencias, e alguem conclui que nao precisa de autorizacao.",
       "esperado": "A autorizacao e antecipada e REGISTRADA, nunca dispensada.",
       "assercoes": [
         {

package/eval/fixtures/b0-slug-e-modos/caso.json

@@ -1,7 +1,10 @@
 {
-  "descricao": "Fixture minima do bloco B0: pedido do builder com #TAG produz slug de 3 partes, blocos do modo e numero de pausas humanas.",
+  "descricao": "Fixture minima do bloco B0: pedido do builder com #TAG de modo VIVO produz slug de 3 partes, blocos do modo e numero de pausas humanas. I-43 tirou daqui os casos de #Look e #Ork: eles pararam de ser escritos, e a recusa deles e provada por fx-modo-aposentado-escritor.",
   "manifesto": {
-    "project": { "name": "orkastery", "abbrev": "ork" }
+    "project": {
+      "name": "orkastery",
+      "abbrev": "ork"
+    }
   },
   "casos": [
     {
@@ -9,31 +12,21 @@
       "nome": "core b0",
       "modoEsperado": "auto",
       "slugEsperado": "ork-coreb0-full",
-      "blocosEsperados": ["GOAL-PLAN-GO-CHECK-SHIP-MASTER"],
+      "blocosEsperados": [
+        "GOAL-PLAN-GO-CHECK-SHIP-MASTER"
+      ],
       "pausasEsperadas": 0
     },
-    {
-      "pedido": "Refatorar o checkout do carrinho #Ork",
-      "nome": "checkout",
-      "modoEsperado": "ork",
-      "slugEsperado": "ork-checkout-f12",
-      "blocosEsperados": ["GOAL-PLAN", "GO", "CHECK", "SHIP", "MASTER"],
-      "pausasEsperadas": 5
-    },
-    {
-      "pedido": "Migracao de dados com risco alto #Look",
-      "nome": "migracao",
-      "modoEsperado": "look",
-      "slugEsperado": "ork-migracao-goal",
-      "blocosEsperados": ["GOAL", "PLAN", "GO", "CHECK", "SHIP", "MASTER"],
-      "pausasEsperadas": 6
-    },
     {
       "pedido": "Ajuste simples e claro no rodape #Maestro",
       "nome": "rodape",
       "modoEsperado": "maestro",
       "slugEsperado": "ork-rodape-f12",
-      "blocosEsperados": ["GOAL-PLAN", "GO-CHECK-SHIP", "MASTER"],
+      "blocosEsperados": [
+        "GOAL-PLAN",
+        "GO-CHECK-SHIP",
+        "MASTER"
+      ],
       "pausasEsperadas": 1
     },
     {
@@ -41,15 +34,35 @@
       "nome": "pipeline",
       "modoEsperado": "classic",
       "slugEsperado": "ork-pipeline-goal",
-      "blocosEsperados": ["GOAL", "PLAN", "GO-CHECK", "SHIP-MASTER"],
+      "blocosEsperados": [
+        "GOAL",
+        "PLAN",
+        "GO-CHECK",
+        "SHIP-MASTER"
+      ],
       "pausasEsperadas": 3
     },
+    {
+      "pedido": "Arruma o typo do rodape #Fast",
+      "nome": "typo rodape",
+      "modoEsperado": "fast",
+      "slugEsperado": "ork-typorodape-go",
+      "blocosEsperados": [
+        "GO"
+      ],
+      "pausasEsperadas": 0
+    },
     {
       "pedido": "Pedido sem tag nenhuma",
       "nome": "semtag",
       "modoEsperado": null,
       "slugEsperado": "ork-semtag-goal",
-      "blocosEsperados": ["GOAL", "PLAN", "GO-CHECK", "SHIP-MASTER"],
+      "blocosEsperados": [
+        "GOAL",
+        "PLAN",
+        "GO-CHECK",
+        "SHIP-MASTER"
+      ],
       "pausasEsperadas": 3
     }
   ]

package/eval/fixtures/b2-master-log/caso.json

@@ -42,7 +42,7 @@
     "fases": ["GOAL", "PLAN", "GO", "CHECK", "SHIP", "MASTER"],
     "score": 4,
     "justificativa": "entregou o combinado; a base andou no meio e exigiu ressincronizacao",
-    "avaliadoPor": "julio",
+    "avaliadoPor": "dono-do-projeto",
     "avaliadoEm": "2026-01-15T12:00:00.000Z",
     "classesDeFalha": ["base-avancou"],
     "resumo": "thread ork-checkout fechada com score 4/5",

package/eval/fixtures/fx-adapter-editado-detectado/caso.json

@@ -0,0 +1,19 @@
+{
+  "id": "fx-adapter-editado-detectado",
+  "sobre": "Uma cópia de adapter editada fora do catálogo continua sendo DETECTADA, NOMEADA e classificada como `copia-editada`, e continua barrando; a saída traz o diff e um caminho de UM comando, sem oferecer `--force`.",
+  "porque": "R1 do GOAL chama esta de a remoção com maior risco, e pelo motivo certo: a cerimônia de instalação é o único mecanismo que pega uma cópia instalada editada à mão, e nenhum teste da suíte alcança isso, porque a suíte roda sobre o CATÁLOGO e não sobre a cópia. Trocar uma recusa barulhenta por nada seria trocar investigação de madrugada por defeito que ninguém vê. O que muda é o que BARRA, não o que DETECTA: no adapter real do Hermes, dos 9 divergentes, 7 são `catalogo-andou` e se resolvem sozinhos, e sobram 2 para o operador decidir — incluindo exatamente o `skills/orkastery-devmaster/SKILL.md` que o dono investigou de madrugada. `naoOfereceForce` é a metade que impede o regime antigo de voltar: `--force` ressincronizava tudo sem mostrar o que mudava, e era o único caminho de saída oferecido.",
+  "precisa": [],
+  "esperado": {
+    "semDivergenciaAoInstalar": true,
+    "reciboGravado": true,
+    "reinstalarNaoAcusa": true,
+    "detectouAEdicao": true,
+    "nomeiaOArquivo": true,
+    "classificouComoCopiaEditada": true,
+    "barrouSemDecisao": true,
+    "temDiffNaSaida": true,
+    "temUmComando": true,
+    "naoOfereceForce": true,
+    "umComandoResolve": true
+  }
+}