@orkastery/cli 0.2.0 → 0.4.1

package/dist/portfolio.js

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

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');
+    }
+}