@orkastery/cli 0.2.0 → 0.3.0

package/dist/preflight.js

@@ -0,0 +1,207 @@
+"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.umaskDoProcesso = umaskDoProcesso;
+exports.sondasDeAmbiente = sondasDeAmbiente;
+exports.checkDeContas = checkDeContas;
+exports.preflight = preflight;
+exports.textoPreflight = textoPreflight;
+/** Preflight contextual de despacho: nenhuma sessão, instalação ou configuração é alterada. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const manifest_1 = require("./manifest");
+const estado_thread_1 = require("./estado-thread");
+const claude_bg_1 = require("./adapters/claude-bg");
+const codex_1 = require("./adapters/codex");
+const runtime_profiles_1 = require("./runtime-profiles");
+const modos_1 = require("./modos");
+const setup_1 = require("./setup");
+const phase_1 = require("./phase");
+const runtimes_1 = require("./runtimes");
+const codex_2 = require("./adapters/codex");
+const runtime_ambiente_1 = require("./runtime-ambiente");
+const slug_1 = require("./slug");
+const util_1 = require("./util");
+const horario_1 = require("./horario");
+const authPadrao = (p) => p.runtime === 'claude-bg' ? (0, claude_bg_1.conferirAuth)(p) : (0, codex_1.conferirAuth)(p);
+const sensoresPadrao = {
+    runtime: nome => !!(0, runtimes_1.resolverRuntime)(nome).disponivel(),
+    sandboxCodex: () => (0, codex_2.sondarSandbox)().ok,
+    auth: authPadrao,
+};
+/** umask efetivo do processo, lido de /proc (Linux) para nao usar o getter deprecado. */
+function umaskDoProcesso() {
+    try {
+        const m = /^Umask:\s*([0-7]+)$/m.exec(fs.readFileSync('/proc/self/status', 'utf8'));
+        return m ? parseInt(m[1], 8) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * I-33 (D7): sonda de umask e das permissoes do estado, coerente com a recusa 0o022 do sensor
+ * (rollout e diretorio pai) e com o 0700 exato da pasta privada (HITL e perfis). Umask que deixa
+ * grupo ou outros escreverem afrouxa o que o runtime cria e o sensor reprova depois.
+ */
+function sondasDeAmbiente(raiz, umask = umaskDoProcesso()) {
+    const checks = [];
+    const octal = (v) => '0' + v.toString(8).padStart(3, '0');
+    checks.push(umask === null ? { nome: 'umask', nivel: 'warn', detalhe: 'umask do processo nao medido nesta plataforma' }
+        : (umask & 0o022) === 0o022 ? { nome: 'umask', nivel: 'ok', detalhe: `umask ${octal(umask)} nega escrita de grupo e outros` }
+            : { nome: 'umask', nivel: 'warn', detalhe: `umask ${octal(umask)} permite escrita de grupo ou outros: o que o runtime criar sera recusado pelo sensor (bits 0o022)`,
+                correcao: 'umask 022 (ou 077) no shell que roda o ork e os runtimes' });
+    const estado = path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery');
+    let st = null;
+    try {
+        st = fs.lstatSync(estado);
+    }
+    catch { /* ausencia e do check de estado do projeto */ }
+    if (st)
+        checks.push(!st.isDirectory() || st.isSymbolicLink() ? { nome: 'permissoes do estado', nivel: 'fail', detalhe: `${estado} nao e diretorio real` }
+            : st.mode & 0o022 ? { nome: 'permissoes do estado', nivel: 'warn', detalhe: `${estado} com modo ${octal(st.mode & 0o777)}: grupo ou outros podem escrever no estado`, correcao: `chmod go-w ${estado}` }
+                : { nome: 'permissoes do estado', nivel: 'ok', detalhe: `${estado} com modo ${octal(st.mode & 0o777)}` });
+    const privada = path.join(estado, 'private');
+    let sp = null;
+    try {
+        sp = fs.lstatSync(privada);
+    }
+    catch { /* criada sob demanda */ }
+    checks.push(!sp ? { nome: 'pasta privada', nivel: 'ok', detalhe: `${privada} ausente: criada sob demanda com 0700` }
+        : !sp.isDirectory() || sp.isSymbolicLink() || sp.uid !== process.getuid?.() || (sp.mode & 0o777) !== 0o700
+            ? { nome: 'pasta privada', nivel: 'fail', detalhe: `${privada} precisa ser diretorio 0700 do proprio usuario (modo ${octal(sp.mode & 0o777)}): recibo HITL e perfis recusam`, correcao: `chmod 700 ${privada}` }
+            : { nome: 'pasta privada', nivel: 'ok', detalhe: `${privada} com modo 0700` });
+    return checks;
+}
+/**
+ * I-33 (D7): contas do runtime do bloco. Sem perfil, o despacho usa o ambiente do processo e
+ * nada e sondado (P8). Com perfis, o bloco so fica pronto com ao menos um perfil disponivel e
+ * com login conferido pelo proprio CLI. A sonda nao marca o store: quem marca e o despacho.
+ */
+function checkDeContas(raiz, runtime, auth = authPadrao) {
+    let perfis;
+    try {
+        perfis = (0, runtime_profiles_1.perfisDoRuntime)((0, runtime_profiles_1.lerPerfisComContas)(raiz), runtime).filter(p => p.estado !== 'desativado');
+    }
+    catch (e) {
+        return { nome: 'contas', nivel: 'fail', detalhe: `store de perfis invalido: ${e.message}` };
+    }
+    if (!perfis.length)
+        return { nome: 'contas', nivel: 'ok', detalhe: `${runtime} sem perfil configurado: despacho pelo ambiente do processo` };
+    const estados = perfis.map(p => {
+        const a = auth((0, runtime_profiles_1.perfilDeDespacho)(p));
+        return { id: p.id, pronto: a.ok && (0, runtime_profiles_1.perfilDisponivel)(p),
+            texto: !a.ok ? `${a.pago ? 'provider pago, nunca despacha' : a.transitorio ? 'conferencia de login inconclusiva' : 'sem login'} (${a.detalhe})` : (0, runtime_profiles_1.perfilDisponivel)(p) ? 'pronto' : `${p.estado}${p.esgotadoAte ? ` ate ${p.esgotadoAte}` : ''}` };
+    });
+    const prontos = estados.filter(e => e.pronto).length;
+    return { nome: 'contas', nivel: prontos === 0 ? 'fail' : prontos < estados.length ? 'warn' : 'ok',
+        detalhe: `${runtime}: ${estados.map(e => `${e.id} ${e.texto}`).join('; ')}`,
+        ...(prontos < estados.length ? { correcao: 'ork accounts check marca os perfis; ork accounts add refaz o login pelo proprio CLI' } : {}) };
+}
+const limites = [
+    'Sonda contextual local: não inventaria sessões, não inicia modelo e não autoriza despacho.',
+    'Aceitação do modelo, instalação do adaptador/MCP, contexto da thread, gates e policies do pedido são revalidados no despacho; com perfis, o login de cada conta é conferido aqui e de novo no despacho.',
+    'Trio sem override; um override posterior exige resolver e verificar novamente o despacho.',
+    'VERIFY/SHIP MCP exigem executor Codex isolado próprio e transporte SHIP válido; a sonda de despacho não comprova entrega.',
+];
+function preflight(raiz, modo, nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)(), sensores = sensoresPadrao) {
+    // I-43: a matriz tem os cinco (para LER thread antiga); quem entra aqui e ESCRITA.
+    if (!modos_1.ORDEM_DOS_MODOS.includes(modo))
+        throw Error('preflight.mode.invalid');
+    const checks = [];
+    checks.push({ nome: 'node', nivel: Number(process.versions.node.split('.')[0]) >= 20 ? 'ok' : 'fail', detalhe: 'Node 20 ou superior necessário' });
+    const git = !!(0, util_1.noPath)('git');
+    checks.push({ nome: 'git', nivel: git ? 'ok' : 'fail', detalhe: git ? 'Git disponível' : 'Git ausente' });
+    const repo = git ? (0, util_1.exec)('git', ['rev-parse', '--is-inside-work-tree'], raiz, 10000) : null;
+    checks.push({ nome: 'repositorio', nivel: repo?.ok && repo.stdout.trim() === 'true' ? 'ok' : 'fail', detalhe: 'Repositório Git local necessário' });
+    checks.push(...sondasDeAmbiente(raiz));
+    const carregado = (0, manifest_1.carregarManifesto)(raiz);
+    const blocos = [];
+    checks.push({ nome: 'manifesto', nivel: !carregado || carregado.erros.length ? 'fail' : 'ok', detalhe: !carregado ? 'Manifesto ausente' : carregado.erros.length ? 'Manifesto inválido; corrija antes do despacho' : 'Manifesto válido' });
+    if (carregado && !carregado.erros.length) {
+        const m = carregado.manifesto;
+        checks.push({ nome: 'modo', nivel: m.conduction.allowed_modes.includes(modo) ? 'ok' : 'fail', detalhe: `Modo solicitado: ${modo}` });
+        checks.push({ nome: 'abbrev', nivel: (0, slug_1.validarAbbrev)(m.project.abbrev).ok ? 'ok' : 'fail', detalhe: 'Identidade curta do projeto validada' });
+        const setup = (0, setup_1.lerSetup)(carregado.raiz), observados = new Map(), contas = new Map();
+        let sandbox;
+        for (const [i, bloco] of modos_1.MODOS[modo].blocos.entries()) {
+            const locais = [];
+            let trio = null;
+            try {
+                trio = (0, phase_1.resolverDespacho)(m, {}, (0, setup_1.configDoBloco)(setup, modo, bloco.fases[0]));
+                (0, runtimes_1.resolverRuntime)(trio.runtime);
+                locais.push({ nome: 'trio', nivel: 'ok', detalhe: 'Runtime/modelo/esforço resolvidos pelo mesmo contrato do despacho; aceitação nativa não comprovada' });
+                if (!observados.has(trio.runtime))
+                    observados.set(trio.runtime, sensores.runtime(trio.runtime));
+                const presente = observados.get(trio.runtime);
+                locais.push({ nome: 'runtime', nivel: presente ? 'ok' : 'fail', detalhe: presente ? `${trio.runtime} disponível` : `${trio.runtime} ausente` });
+                if (presente) {
+                    if (!contas.has(trio.runtime))
+                        contas.set(trio.runtime, checkDeContas(carregado.raiz, trio.runtime, sensores.auth ?? authPadrao));
+                    locais.push(contas.get(trio.runtime));
+                }
+                if (trio.runtime === 'codex' && presente) {
+                    sandbox ??= sensores.sandboxCodex();
+                    locais.push({ nome: 'sandbox de despacho', nivel: sandbox ? 'ok' : m.runtime.sandbox === 'danger-full-access' ? 'warn' : 'fail', detalhe: sandbox ? 'Sonda Codex sem modelo executou' : 'Sonda Codex falhou; não altere o sandbox para contornar a falha' });
+                }
+                const ativos = nomesHerdados.filter(n => runtime_ambiente_1.ENVS_DE_PROVIDER_PAGO.includes(n));
+                const relevantes = ativos.filter(n => trio.runtime === 'claude-bg' ? /^(ANTHROPIC_|CLAUDE_CODE_USE_)/.test(n) : /^(OPENAI_|OPENROUTER_)/.test(n));
+                locais.push({ nome: 'provider', nivel: m.runtime.provider_policy === 'subscription-only' && relevantes.length ? 'fail' : ativos.length ? 'warn' : 'ok', detalhe: relevantes.length ? `Nomes de provider incompatíveis com assinatura: ${relevantes.join(', ')}` : ativos.length ? 'Há nomes de provider alheios ao runtime; não usar credenciais pagas' : 'Nenhum nome de provider pago ativo' });
+            }
+            catch {
+                locais.push({ nome: 'trio', nivel: 'fail', detalhe: 'Setup/trio ou sonda inválidos; complete o modelo e confira o runtime no setup canônico' });
+            }
+            blocos.push({ numero: i + 1, fases: [...bloco.fases], trio, checks: locais, pronto: locais.every(c => c.nivel !== 'fail') });
+        }
+    }
+    const basePronta = checks.every(c => c.nivel !== 'fail');
+    return { modo, scope: 'dispatch-local', checks, blocos,
+        prontoPrimeiroBloco: basePronta && !!blocos[0]?.pronto,
+        prontoTodosBlocos: basePronta && blocos.length > 0 && blocos.every(b => b.pronto),
+        entrega: { verificada: false, dependencias: ['executor Codex isolado', 'transporte SHIP instalado', 'gates e HEADs correntes'] }, limites: [...limites] };
+}
+function textoPreflight(r) {
+    // I-35: o Check guarda o ISO (dado de maquina); quem imprime para o dono localiza.
+    let localizou = false;
+    const local = (t) => { const l = (0, horario_1.localizarTexto)(t); if (l !== t)
+        localizou = true; return l; };
+    const linhas = ['ork doctor contextual: ' + r.modo, ...r.checks.map(c => `${c.nivel}: ${c.nome}: ${local(c.detalhe)}`),
+        ...r.blocos.flatMap(b => [`bloco ${b.numero} ${b.fases.join('→')}: ${b.trio ? `${b.trio.runtime}/${b.trio.model}/${b.trio.effort}` : 'trio pendente'}`, ...b.checks.map(c => `  ${c.nivel}: ${c.nome}: ${local(c.detalhe)}`)]),
+        `Primeiro bloco: ${r.prontoPrimeiroBloco ? 'sonda pronta' : 'bloqueado'}; todos os blocos: ${r.prontoTodosBlocos ? 'sonda pronta' : 'dependências pendentes'}`, ...r.limites];
+    // O fuso sai uma vez por mensagem, depois dos limites.
+    if (localizou)
+        linhas.push((0, horario_1.legendaDoFuso)());
+    return linhas.join('\n');
+}

package/dist/process-audit.js

@@ -0,0 +1,112 @@
+"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.inspecionarProcesso = inspecionarProcesso;
+exports.auditarProcesso = auditarProcesso;
+/** PR1..PR3 derivados do estado canônico, sem runtime de LLM. */
+const fs = __importStar(require("node:fs"));
+const node_crypto_1 = require("node:crypto");
+const thread_1 = require("./thread");
+const ledger_1 = require("./ledger");
+const master_1 = require("./master");
+const thread_close_1 = require("./thread-close");
+const estado_thread_1 = require("./estado-thread");
+const divida_1 = require("./divida");
+const auditoria_1 = require("./auditoria");
+function inspecionarProcesso(raiz) {
+    const achados = [], motivos = new Map();
+    const adicionar = (regra, threads, motivo) => {
+        threads.sort();
+        const chave = (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(regra === 'PR3' ? [regra, motivo] : [regra, threads, motivo])).digest('hex');
+        achados.push({ regra, chave, threads, motivo, evidencia: threads.map(id => `.orkastery/threads/${id}/ledger.jsonl`) });
+    };
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        const t = (0, thread_1.lerThread)(raiz, id), eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
+        if (!t.fechamentoAdmin && (0, thread_close_1.provaDeEntrega)(raiz, id)) {
+            let temLog = false;
+            try {
+                const log = JSON.parse(fs.readFileSync((0, master_1.caminhoMasterLog)(raiz, id), 'utf8'));
+                temLog = log.thread === id && [master_1.CONTRATO_MASTER_LOG, master_1.CONTRATO_MASTER_PENDENTE].includes(log.contrato);
+            }
+            catch { /* ausência ou JSON inválido é PR1 */ }
+            if (!temLog)
+                adicionar('PR1', [id], 'entrega sem MASTER log válido');
+            if (!(0, master_1.masterRatificado)(raiz, id))
+                adicionar('PR2', [id], 'entrega sem ratificação humana');
+        }
+        for (const e of eventos)
+            if (e.tipo === 'gate_blocked' && typeof e.motivo === 'string' && e.motivo.trim()) {
+                const ids = motivos.get(e.motivo) ?? new Set();
+                ids.add(id);
+                motivos.set(e.motivo, ids);
+            }
+    }
+    for (const [motivo, ids] of motivos)
+        if (ids.size >= 2)
+            adicionar('PR3', [...ids], motivo);
+    return achados.sort((a, b) => a.chave.localeCompare(b.chave));
+}
+function auditarProcesso(carregado, registrarNoBoard = false) {
+    const raiz = (0, estado_thread_1.raizDoEstado)(carregado.raiz), { manifesto } = carregado;
+    const achados = inspecionarProcesso(raiz), postura = auditoria_1.POSTURA_DO_ESTAGIO[manifesto.project.stage];
+    const ids = [];
+    if (registrarNoBoard) {
+        const existentes = (0, divida_1.lerBoard)(raiz);
+        for (const a of achados) {
+            const rodada = `process-${a.chave}`;
+            const anterior = existentes.find(e => e.rodada === rodada && e.regra === a.regra);
+            if (anterior) {
+                const descricao = `${a.threads.join(', ')}: ${a.motivo}`;
+                if (anterior.descricao !== descricao || anterior.arquivo !== a.evidencia[0]) {
+                    (0, divida_1.carimbarAchado)(raiz, anterior, { descricao, arquivo: a.evidencia[0],
+                        claim: { ...anterior.claim, arquivo: a.evidencia[0], alegacao: `${a.regra} observado em ${a.threads.join(', ')}` } });
+                }
+                ids.push(anterior.id);
+                continue;
+            }
+            const comando = `node core/dist/index.js audit process --exigir-achado ${a.chave}`;
+            const r = (0, divida_1.registrarAchado)(raiz, { rodada, pack: 'process', regra: a.regra, severidade: 'menor',
+                titulo: `${a.regra}: ${a.motivo}`, arquivo: a.evidencia[0], descricao: `${a.threads.join(', ')}: ${a.motivo}`,
+                alegacao: `${a.regra} observado em ${a.threads.join(', ')}`, verificar: [comando],
+                impacto: 'Entrega ou repetição de falha sem aprendizado humano confirmado',
+                fix: a.regra === 'PR3' ? 'Revisar o motivo recorrente e propor controle no roadmap' : 'Revisar a entrega e concluir MASTER com ratificação humana',
+                estimativa: '1h', irreversivel: 'nenhum', produto: manifesto.project.name, estagio: manifesto.project.stage,
+                postura, memory: manifesto.memory.mode });
+            existentes.push(r);
+            ids.push(r.id);
+        }
+    }
+    return { contrato: 'ork.process-audit/v1', postura, achados, board: ids };
+}

package/dist/project-state.js

@@ -0,0 +1,93 @@
+"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.projectState = projectState;
+exports.stateFile = stateFile;
+exports.stateFileStatus = stateFileStatus;
+exports.memoryState = memoryState;
+/** D3: estado da main validada; código e verificadores continuam na candidata. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const manifest_1 = require("./manifest");
+function projectState(root) {
+    try {
+        const codeRoot = fs.realpathSync(root);
+        const canonical = fs.realpathSync((0, estado_thread_1.raizDoEstado)(codeRoot));
+        return { root: canonical, codeRoot, linked: canonical !== codeRoot };
+    }
+    catch {
+        throw new Error('project-state.root.invalid');
+    }
+}
+function stateFile(root, name) {
+    const state = projectState(root);
+    const target = path.join(state.root, '.orkastery', name);
+    // Uma leitura da WT não pode criar uma segunda autoridade por falta da fonte.
+    if (state.linked && !fs.existsSync(target))
+        throw new Error('project-state.source.missing');
+    return target;
+}
+/** Diagnóstico separado da leitura: cópias locais nunca substituem a autoridade. */
+function stateFileStatus(root, name) {
+    const state = projectState(root);
+    const source = stateFile(root, name);
+    const local = path.join(state.codeRoot, '.orkastery', name);
+    const divergent = state.linked && fs.existsSync(local) &&
+        !fs.readFileSync(local).equals(fs.readFileSync(source));
+    return { ...state, source, divergent };
+}
+/** Resolve somente a configuração de memória, sem trocar paths de código/build. */
+function memoryState(loaded) {
+    const state = projectState(loaded.raiz);
+    if (!state.linked)
+        return { loaded, source: loaded.caminho, divergent: false };
+    try {
+        if (![manifest_1.NOME_MANIFESTO, manifest_1.NOME_MANIFESTO_LEGADO].some(n => fs.existsSync(path.join(state.root, n)))) {
+            throw new Error('missing');
+        }
+        const canonical = (0, manifest_1.exigirManifesto)(state.root);
+        if (canonical.raiz !== state.root)
+            throw new Error('invalid');
+        return {
+            loaded: { ...loaded, manifesto: { ...loaded.manifesto, memory: canonical.manifesto.memory } },
+            source: canonical.caminho,
+            divergent: JSON.stringify(loaded.manifesto.memory) !== JSON.stringify(canonical.manifesto.memory),
+        };
+    }
+    catch {
+        throw new Error('project-state.memory.unavailable');
+    }
+}

package/dist/prompts.js

@@ -160,7 +160,7 @@ exports.SECOES_OBRIGATORIAS = [
     '## Pedido do builder',
     '## Regras de evidencia',
 ];
-/** A frase que nenhum template pode perder, porque ela e o contrato dos 5 modos. */
+/** A frase que nenhum template pode perder, porque ela e o contrato de todo modo. */
 exports.REGRA_CENTRAL = 'REGRA CENTRAL: o modo afrouxa a pausa, NUNCA a verificacao.';
 /** O contrato do prompt de fase (o do B4). */
 exports.CONTRATO_DE_FASE = {
@@ -241,18 +241,29 @@ function lintTemplate(t, contrato = exports.CONTRATO_DE_FASE) {
  *
  * Ele e a fonte de verdade do prompt do `ork` e a copia versionada em `prompts/fase-padrao.md`
  * precisa ser identica byte a byte (ha teste que prova isso). Renderizado, ele produz
- * exatamente o prompt que o B0 montava por concatenacao: mudar o texto aqui e mudar contrato.
+ * o contrato distribuido a projetos sem override; mudar o texto exige sincronizar a copia.
  */
 exports.TEMPLATE_FASE_PADRAO = `---
 id: fase-padrao
-versao: 2
+versao: 3
 descricao: Prompt canonico de uma fase do ciclo GOAL..MASTER, com nomenclatura, modo de conducao, contexto da thread, memoria injetada e regras de evidencia.
 fases: [GOAL, PLAN, GO, CHECK, SHIP, MASTER]
 variaveis: [fase, thread, bloco, nome, ciclo_canonico, tag, blocos, pausas, linha_variante, regra_de_pausa, invariantes, slug, projeto_nome, projeto_abbrev, base_branch, base_commit, diretorio, pedido, memoria_injetada, regras_de_evidencia]
 ---
 # Orkastery, fase {{fase}} da thread {{thread}}
 
-Voce conduz o bloco {{bloco}} da thread "{{nome}}".
+Voce conduz o bloco {{bloco}} da thread "{{nome}}". {{fase}} e a fase de entrada, nao uma nova orquestracao.
+Execute as fases deste bloco na ordem canonica, respeitando o escopo de cada fase e os gates do nucleo; GOAL nao implementa antes de GO.
+Nao abra outra thread nem redespache a si mesmo. Se houver MCP do projeto, prefira suas ferramentas para estado e operacoes suportadas.
+No Claude com servidor \`orkastery\`, use nomes completos expostos: \`ToolSearch\` com \`select:mcp__orkastery__ork_thread_status,mcp__orkastery__ork_artifact_read\` descobre essas leituras; para outra ferramenta, selecione seu nome completo. Nao busque \`select:ork_thread_status\`. Outros hosts usam seu namespace descoberto.
+Quando disponiveis, use ork_artifact_read/write para objetivo, plano e parecer, e ork_claims_list/ork_claim_add para claims; nao escreva ledger nem estado canonico diretamente.
+Decisao que voce tomar sem perguntar ao dono vai ao ledger por \`ork decisao registrar <thread>\`, com o que foi decidido, o porque, como mudar, o custo de reverter agora e depois, o criterio escrito, quem decidiu e a evidencia; e assim que ela chega ao dono no resumo, em vez de sumir na conversa.
+Artefato de autoria do agente nao e recibo oficial; cadastrar claim nao significa verifica-la.
+Para registrar produto, prefira ork_git_commit com HEAD atual e paths com claims; use ork_verify para verificacao real e ork_ship com HEADs fonte/destino conferidos para entrega. Commit local nao e SHIP; retorno incomplete exige reconciliar estado e remoto antes de repetir. Permissao para consultar nao concede essas operacoes: respeite a autorizacao nativa e os gates.
+Decisao do dono deve ser apresentada pela sessao condutora ao host; a sessao filha nao responde nem assume a identidade do dono.
+Preserve o perfil filho configurado: \`interactive\` concede consultas; \`worktree\` exige opt-in da instalacao e autoriza ferramentas exatas na WT validada, sem aprovar gates ou assumir o dono. Nao mude configuracao para contornar bloqueio.
+Consulte \`ork_git_status\` para HEADs reais e estado Git; use \`ork_git_commit\`, \`ork_verify\` e \`ork_ship\` pelos contratos do nucleo, sem Bash Git nem inventar SHAs. Use \`source.head\` como \`expectedHead\` do commit; consulte novamente apos commit e use \`source.head\`/\`destination.head\` como \`expectedSource\`/\`expectedDestination\` do SHIP. Base historica nao substitui a consulta atual. As regras Edit/deny sao permissoes nativas de ferramentas, nao sandbox de processos.
+Permissao nativa ou operacao sem transporte suportado continua um impedimento real, nunca motivo para alterar o sandbox.
 
 ## Ciclo canonico
 {{ciclo_canonico}}
@@ -278,6 +289,14 @@ REGRA CENTRAL: o modo afrouxa a pausa, NUNCA a verificacao.
 {{pedido}}
 {{memoria_injetada}}
 
+## Isolamento por sessão
+
+O runtime pode ser o mesmo da condutora e do revisor. A independência exige IDs nativos
+distintos e vínculos comprovados pelo núcleo; nome de papel no prompt não é autoridade.
+Esta sessão executa o bloco recebido, sem abrir recursão, aprovar gate ou validar o próprio
+trabalho. Preserve runtime/modelo/esforço e perfil \`interactive\`/\`worktree\` já configurados.
+Falha de autenticação permanece impedimento; não troque provider, sandbox ou identidade.
+
 ## Regras de evidencia
 {{regras_de_evidencia}}`;
 /** Os templates que vem dentro do `ork`, por id. */
@@ -387,7 +406,8 @@ function threadDeExemplo(modo, fase, projeto) {
         nome: 'exemplo de prompt',
         assunto: 'exemplo',
         modo,
-        fases: [...types_1.FASES],
+        // I-42: as fases saem dos blocos do modo; no `#Fast` e so a GO.
+        fases: def.blocos.flatMap((b) => b.fases),
         blocos: def.blocos,
         faseAtual: fase,
         status: 'aberta',

package/dist/prova-minima.js

@@ -0,0 +1,112 @@
+"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.LIMITE_DE_COMANDOS_SEM_CHECK = void 0;
+exports.cicloSemCheck = cicloSemCheck;
+exports.testeFocado = testeFocado;
+exports.comandoDoTesteFocado = comandoDoTesteFocado;
+exports.validarProvaSemCheck = validarProvaSemCheck;
+exports.registrarProvaAusente = registrarProvaAusente;
+/**
+ * I-42 (D4, D5): a prova minima de um ciclo sem CHECK, em tres degraus.
+ *
+ *  1. Teste focado: havendo teste homonimo para algum caminho do commit (ou sendo o caminho um
+ *     teste), roda so ele e grava comando e codigo de saida.
+ *  2. Claim retrospectiva: sem teste homonimo, uma claim de uma linha com ate dois comandos
+ *     baratos. O nucleo recusa claim que rode a suite inteira do manifesto (custo medido na I-42:
+ *     227,6 s contra ~12 s do teste focado).
+ *  3. Ausencia declarada: sem teste nem comando honesto, o evento `prova_ausente` registra os
+ *     caminhos sem prova e o motivo. Nao ha prova fingida e nao ha ausencia em silencio.
+ *
+ * O que nao acontece em degrau nenhum: baseline do manifesto ou a suite completa.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+/** Teto de comandos por claim num ciclo sem CHECK (degrau 2). */
+exports.LIMITE_DE_COMANDOS_SEM_CHECK = 2;
+/** O ciclo da thread nao tem CHECK: a prova e a minima, feita pela propria GO. */
+function cicloSemCheck(thread) {
+    return !thread.blocos.some((b) => b.fases.includes('CHECK'));
+}
+/**
+ * O teste focado de um caminho, por convencao: `core/src/X.ts` -> `core/test/X.test.ts`, e um
+ * `core/test/X.test.ts` e o proprio teste. Devolve o caminho do teste, ou null quando nao ha.
+ */
+function testeFocado(raiz, caminho) {
+    const c = caminho.replace(/\\/g, '/');
+    if (/^core\/test\/[^/]+\.test\.ts$/.test(c))
+        return fs.existsSync(path.join(raiz, c)) ? c : null;
+    const m = /^core\/src\/([^/]+)\.ts$/.exec(c);
+    if (!m)
+        return null;
+    const teste = `core/test/${m[1]}.test.ts`;
+    return fs.existsSync(path.join(raiz, teste)) ? teste : null;
+}
+/** O comando que roda so o teste focado (degrau 1). */
+function comandoDoTesteFocado(teste) {
+    const nome = path.basename(teste).replace(/\.ts$/, '.js');
+    return `npm --prefix core run build:test && node --test core/dist-test/test/${nome}`;
+}
+/**
+ * Recusa a claim que fura o degrau 2: mais comandos do que o teto, ou a suite inteira do
+ * manifesto. Mensagem tipada, com a saida certa.
+ */
+function validarProvaSemCheck(verificar, comandoDeTesteDoManifesto) {
+    if (verificar.length > exports.LIMITE_DE_COMANDOS_SEM_CHECK) {
+        throw new Error(`claims.custo: ciclo sem CHECK aceita ate ${exports.LIMITE_DE_COMANDOS_SEM_CHECK} comandos por claim ` +
+            `(recebidos ${verificar.length}); use o teste focado ou declare a ausencia com ork claims ausente`);
+    }
+    const suite = comandoDeTesteDoManifesto?.trim();
+    if (suite && verificar.some((c) => c.includes(suite))) {
+        throw new Error(`claims.custo: ciclo sem CHECK nao roda a suite inteira ("${suite}"); ` +
+            'use o teste focado do arquivo que mudou');
+    }
+}
+/** Degrau 3: grava no ledger da thread que estes caminhos ficaram sem prova, e por que. */
+function registrarProvaAusente(raiz, threadId, ausencia) {
+    (0, thread_1.lerThread)(raiz, threadId); // a thread tem de existir
+    const motivo = ausencia.motivo.trim();
+    if (!motivo)
+        throw new Error('prova.ausente: o motivo e obrigatorio (uma linha)');
+    if (ausencia.paths.length === 0)
+        throw new Error('prova.ausente: informe os caminhos que ficaram sem prova');
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.provaAusente, {
+        paths: ausencia.paths,
+        motivo,
+        ...(ausencia.commit ? { commit: ausencia.commit } : {}),
+    });
+}