@orkastery/cli 0.2.0 → 0.4.1

package/dist/company-brain-cli.js

@@ -0,0 +1,123 @@
+"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.BRAIN_WRITE = exports.BRAIN_READ = void 0;
+exports.runBrain = runBrain;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const project_state_1 = require("./project-state");
+const portfolio_1 = require("./portfolio");
+const thread_1 = require("./thread");
+const write_activation_1 = require("./write-activation");
+const ledger_1 = require("./ledger");
+const company_brain_client_1 = require("./company-brain-client");
+const company_brain_capture_1 = require("./company-brain-capture");
+const company_brain_source_1 = require("./company-brain-source");
+const company_brain_migration_1 = require("./company-brain-migration");
+const company_brain_journal_1 = require("./company-brain-journal");
+const company_brain_contract_1 = require("./company-brain-contract");
+exports.BRAIN_READ = ['status', 'inventory', 'get', 'query', 'receipts', 'reconcile'];
+exports.BRAIN_WRITE = ['sync', 'apply', 'rollback', 'bind'];
+function runBrain(c, sub, options, positionals = [], transport) {
+    const context = (0, project_state_1.memoryState)(c);
+    c = context.loaded;
+    const config = c.manifesto.memory;
+    if (![...exports.BRAIN_READ, ...exports.BRAIN_WRITE].includes(sub))
+        throw Error('brain.operation.invalid');
+    const allowed = new Set(['thread', 'json', 'id', 'ids', 'kinds', 'workspaces', 'limit', 'offset', 'batch', 'dry-run', 'plan', 'expected-sha256', 'project', 'initiatives']);
+    if (Object.keys(options).some(k => !allowed.has(k)))
+        throw Error('brain.argument.invalid');
+    const value = (name) => typeof options[name] === 'string' ? options[name] : undefined;
+    const thread = value('thread');
+    let scope = { tenant: config.tenant, instance: c.manifesto.project.name, thread: thread ?? '', aclRef: 'ork-factory' };
+    const client = transport ?? (0, company_brain_client_1.brainClient)(c);
+    if (sub === 'status')
+        return { ...client({ schema: company_brain_client_1.BRAIN_API, operation: 'capabilities' }), tenant: config.tenant, configSource: context.source };
+    if (sub === 'get' || sub === 'receipts')
+        return client({ schema: company_brain_client_1.BRAIN_API, operation: sub, payload: { tenant_id: config.tenant, [sub === 'get' ? 'id' : 'event_id']: value('id') ?? positionals[0] ?? '' } });
+    if (sub === 'query' || sub === 'inventory') {
+        const split = (name) => (value(name) ?? '').split(',').filter(Boolean);
+        return client({ schema: company_brain_client_1.BRAIN_API, operation: 'query', payload: (0, company_brain_contract_1.validateContract)({ schema: 'orkmind.company-brain-selection/v1', tenant_id: config.tenant,
+                facets: { ids: split('ids'), kinds: split('kinds'), workspace_ids: split('workspaces'), source_instances: [] }, mode: 'selection', limit: Number(value('limit') ?? 50), offset: Number(value('offset') ?? 0) }) });
+    }
+    if (!thread)
+        throw Error('brain.thread.required');
+    (0, thread_1.lerThread)(c.raiz, thread);
+    if (sub === 'reconcile') {
+        if (options['dry-run'] !== true)
+            throw Error('brain.migration.dry-run-required');
+        return { state: 'ok', ...(0, company_brain_migration_1.reconcileBrain)(c, scope, value('batch') ?? 'inventory-' + (0, company_brain_contract_1.digest)((0, portfolio_1.readPortfolio)(c.raiz)).slice(0, 20)) };
+    }
+    // Existing reviewed activation plus dedicated Brain DB grants: neither grants the other.
+    (0, write_activation_1.exigirAtivacao)(c, thread, 'memory');
+    const dir = (0, thread_1.dirThread)(c.raiz, thread);
+    if (sub === 'bind') {
+        const selection = (0, portfolio_1.assertCycleScope)(c.raiz, { projectId: value('project') ?? '', delivery: 'initiatives', initiativeIds: (value('initiatives') ?? '').split(',').filter(Boolean) });
+        const binding = { schema: 'ork.brain-cycle-scope/v1', version: 1, thread, ...selection };
+        const file = path.join(dir, 'brain-scope.json');
+        if (fs.existsSync(file)) {
+            if ((0, company_brain_contract_1.digest)(JSON.parse(fs.readFileSync(file, 'utf8'))) !== (0, company_brain_contract_1.digest)(binding))
+                throw Error('brain.scope.immutable');
+            return { state: 'ok', binding };
+        }
+        (0, company_brain_journal_1.atomicJson)(file, binding);
+        (0, ledger_1.registrar)(dir, thread, 'brain_scope_recorded', { binding, sha256: (0, company_brain_contract_1.digest)(binding) });
+        return { state: 'ok', binding };
+    }
+    if (sub === 'sync') {
+        const bindingFile = path.join(dir, 'brain-scope.json');
+        if (fs.existsSync(bindingFile)) {
+            const binding = JSON.parse(fs.readFileSync(bindingFile, 'utf8'));
+            if (binding.schema !== 'ork.brain-cycle-scope/v1' || binding.version !== 1 || binding.thread !== thread)
+                throw Error('brain.scope.invalid');
+            const selection = (0, portfolio_1.assertCycleScope)(c.raiz, { projectId: binding.projectId, delivery: binding.delivery, initiativeIds: binding.initiativeIds });
+            scope = { ...scope, projectId: selection.projectId, initiativeIds: selection.initiativeIds };
+        }
+        return (0, company_brain_capture_1.capture)(scope, path.join(dir, 'brain'), (0, portfolio_1.readPortfolio)(c.raiz), (0, company_brain_source_1.readSourceFile)(path.join(dir, 'ledger.jsonl')), client, undefined, (0, company_brain_journal_1.readJournal)((0, project_state_1.stateFile)(c.raiz, 'portfolio.json') + '.journal.jsonl'));
+    }
+    if (sub === 'apply') {
+        const filename = value('plan');
+        if (!filename)
+            throw Error('brain.migration.plan-required');
+        const file = path.resolve(c.raiz, filename);
+        if (!file.startsWith(path.resolve(c.raiz) + path.sep))
+            throw Error('brain.migration.path-invalid');
+        const plan = JSON.parse((0, company_brain_source_1.readSourceFile)(file, 2 * 1024 * 1024).toString('utf8'));
+        return (0, company_brain_migration_1.applyBrain)(c, plan, value('expected-sha256') ?? '');
+    }
+    if (sub === 'rollback')
+        return (0, company_brain_migration_1.brainAdmin)(c)('rollback', { batch_id: value('batch') ?? '' });
+    throw Error('brain.operation.invalid');
+}

package/dist/company-brain-client.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRAIN_API = void 0;
+exports.validateRequest = validateRequest;
+exports.brainClient = brainClient;
+const node_child_process_1 = require("node:child_process");
+const project_state_1 = require("./project-state");
+const company_brain_contract_1 = require("./company-brain-contract");
+exports.BRAIN_API = 'orkmind.company-brain-api/v1';
+function validateRequest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || value.schema !== exports.BRAIN_API ||
+        Object.keys(value).some(k => !['schema', 'operation', 'payload'].includes(k)) ||
+        !['capabilities', 'ingest', 'get', 'query', 'receipts', 'head'].includes(value.operation))
+        throw Error('brain.api.invalid');
+    if (['ingest', 'query'].includes(value.operation)) {
+        const body = (0, company_brain_contract_1.validateContract)(value.payload);
+        if (body.schema !== `orkmind.company-brain-${value.operation === 'ingest' ? 'event' : 'selection'}/v1`)
+            throw Error('brain.api.invalid');
+    }
+    if (['get', 'receipts', 'head'].includes(value.operation)) {
+        const keys = ['tenant_id', value.operation === 'receipts' ? 'event_id' : 'id'];
+        if (!value.payload || Object.keys(value.payload).length !== 2 || keys.some(k => typeof value.payload[k] !== 'string' ||
+            !/^[a-zA-Z0-9][a-zA-Z0-9._:/-]{0,159}$/.test(value.payload[k])))
+            throw Error('brain.api.invalid');
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+function brainClient(loaded, execute = node_child_process_1.spawnSync) {
+    const context = (0, project_state_1.memoryState)(loaded), config = context.loaded.manifesto.memory;
+    return raw => {
+        const request = validateRequest(raw);
+        const unavailable = (error) => ({ schema: exports.BRAIN_API, state: 'unavailable', error });
+        const dsn = config.database_url_env ? process.env[config.database_url_env] : undefined;
+        if (config.mode !== 'orkmind' || (!dsn && request.operation !== 'capabilities'))
+            return unavailable('brain.configuration.missing');
+        const payload = request.payload;
+        if (payload?.tenant_id !== undefined && payload.tenant_id !== config.tenant)
+            return { schema: exports.BRAIN_API, state: 'forbidden', error: 'brain.tenant.mismatch' };
+        const result = execute(config.cli, ['brain', 'request'], { cwd: loaded.raiz, encoding: 'utf8', timeout: Math.min(config.timeout_ms, 15000),
+            maxBuffer: 2 * 1024 * 1024, input: JSON.stringify(request), shell: false,
+            env: { PATH: process.env.PATH ?? '/usr/bin:/bin', PYTHONDONTWRITEBYTECODE: '1',
+                ORKMIND_DATABASE_URL: dsn ?? '', ORKMIND_BRAIN_TENANT: config.tenant } });
+        if (result.error || result.signal)
+            return unavailable('brain.transport.unavailable');
+        try {
+            const response = JSON.parse(String(result.stdout));
+            if (response.schema !== exports.BRAIN_API || !['ok', 'empty', 'unknown', 'unavailable', 'withheld', 'forbidden', 'conflict'].includes(response.state))
+                throw Error();
+            if (response.state === 'ok' && result.status !== 0)
+                throw Error();
+            if (request.operation === 'capabilities' && response.state === 'ok' && response.contract_hash !== company_brain_contract_1.CONTRACT_HASH)
+                return unavailable('brain.contract.mismatch');
+            if (response.error && !/^brain\.[a-z0-9.-]+$/.test(response.error))
+                return unavailable('brain.transport.invalid');
+            return response;
+        }
+        catch {
+            return unavailable('brain.transport.invalid');
+        }
+    };
+}

package/dist/company-brain-contract.js

@@ -0,0 +1,166 @@
+"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.digest = exports.canonical = exports.CONTRACT_HASH = void 0;
+exports.validateContract = validateContract;
+exports.validateCatalog = validateCatalog;
+/** D6: consume o schema canônico OrkMind; transporte não concede autoridade. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const file = path.resolve(__dirname, __dirname.endsWith(`${path.sep}src`) ? '../../schemas/company-brain.schema.json' : '../schemas/company-brain.schema.json');
+const schema = JSON.parse(fs.readFileSync(file, 'utf8'));
+exports.CONTRACT_HASH = (0, node_crypto_1.createHash)('sha256').update(fs.readFileSync(file)).digest('hex');
+const canonical = (v) => Array.isArray(v) ? `[${v.map(exports.canonical).join(',')}]`
+    : v !== null && typeof v === 'object' ? `{${Object.keys(v).sort().map(k => `${JSON.stringify(k)}:${(0, exports.canonical)(v[k])}`).join(',')}}`
+        : JSON.stringify(v);
+exports.canonical = canonical;
+const digest = (v) => (0, node_crypto_1.createHash)('sha256').update((0, exports.canonical)(v)).digest('hex');
+exports.digest = digest;
+const fail = () => { throw Error('brain.contract.invalid'); };
+/** Closed vocabulary emitted by Pydantic. Unknown validation keywords fail closed. */
+function matches(v, rule, depth = 0) {
+    if (depth > 32)
+        return false;
+    const known = ['$ref', 'anyOf', 'type', 'const', 'enum', 'properties', 'required', 'additionalProperties', 'items',
+        'minItems', 'maxItems', 'minLength', 'maxLength', 'pattern', 'minimum', 'maximum', 'title', 'description'];
+    if (Object.keys(rule).some(k => !known.includes(k)))
+        return false;
+    if (rule.$ref)
+        return rule.$ref.startsWith('#/$defs/') && matches(v, schema.$defs[rule.$ref.slice(8)], depth + 1);
+    if (rule.anyOf)
+        return rule.anyOf.some((r) => matches(v, r, depth + 1));
+    if ('const' in rule && v !== rule.const || rule.enum && !rule.enum.includes(v))
+        return false;
+    switch (rule.type) {
+        case 'null': return v === null;
+        case 'boolean': return typeof v === 'boolean';
+        case 'integer': return Number.isSafeInteger(v) && (rule.minimum === undefined || v >= rule.minimum) && (rule.maximum === undefined || v <= rule.maximum);
+        case 'string': return typeof v === 'string' && (rule.minLength === undefined || [...v].length >= rule.minLength) &&
+            (rule.maxLength === undefined || [...v].length <= rule.maxLength) && (!rule.pattern || new RegExp(rule.pattern, 'u').test(v));
+        case 'array': return Array.isArray(v) && (rule.minItems === undefined || v.length >= rule.minItems) &&
+            (rule.maxItems === undefined || v.length <= rule.maxItems) && v.every(i => matches(i, rule.items, depth + 1));
+        case 'object': return v !== null && typeof v === 'object' && !Array.isArray(v) &&
+            (!rule.required || rule.required.every((k) => Object.hasOwn(v, k))) &&
+            Object.keys(v).every(k => Object.hasOwn(rule.properties ?? {}, k) ? matches(v[k], rule.properties[k], depth + 1) : rule.additionalProperties !== false);
+        default: return false;
+    }
+}
+function semantic(v) {
+    for (const [key, value] of Object.entries(v))
+        if ((key.endsWith('_at') || ['valid_from', 'valid_to'].includes(key)) && value !== null) {
+            const time = new Date(value);
+            if (!Number.isFinite(time.getTime()) || time.toISOString().slice(0, 19) !== value.slice(0, 19))
+                fail();
+        }
+    if (v.schema.endsWith('entity/v1')) {
+        if (!v.id.startsWith(v.kind + '-'))
+            fail();
+        if (v.kind === 'prod' ? v.parent_id !== null : !v.parent_id?.startsWith(v.kind === 'proj' ? 'prod-' : 'proj-'))
+            fail();
+        if (v.kind !== 'init' && v.depends_on.length || v.kind !== 'proj' && v.workspace_ids.length)
+            fail();
+        if (v.depends_on.some((d) => !d.startsWith('init-') || d === v.id))
+            fail();
+        if ((v.owner.raw === null) !== (v.owner.state === 'unknown'))
+            fail();
+    }
+    if (v.schema.endsWith('event/v1')) {
+        if ((0, exports.digest)(v.payload) !== v.payload_hash || (v.operation === 'tombstone') !== (v.payload === null))
+            fail();
+        if (v.payload !== null) {
+            validateContract(v.payload);
+            if (v.payload.tenant_id !== v.tenant_id || v.payload.id !== v.aggregate_id || v.payload.acl_ref !== v.acl_ref ||
+                (0, exports.canonical)(v.payload.source) !== (0, exports.canonical)(v.source) ||
+                v.operation !== (v.payload.schema.endsWith('entity/v1') ? 'upsert' : 'assert'))
+                fail();
+        }
+    }
+    if (v.schema.endsWith('assertion/v1')) {
+        if (v.object_id !== null && v.value !== null || v.valid_from && v.valid_to && v.valid_from >= v.valid_to)
+            fail();
+    }
+    if (v.schema.endsWith('migration/v1'))
+        for (const op of v.operations) {
+            validateContract(op.after);
+            if (op.id !== op.after.id || op.after.tenant_id !== v.tenant_id)
+                fail();
+        }
+}
+function validateContract(value) {
+    try {
+        if (!schema.anyOf.some((r) => matches(value, r)))
+            fail();
+        semantic(value);
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return fail();
+    }
+}
+function validateCatalog(values, scope) {
+    const entities = values.map(v => validateContract(v));
+    if (entities.some(e => e.schema !== 'orkmind.company-brain-entity/v1'))
+        fail();
+    const ids = new Map(entities.map(e => [e.id, e]));
+    if (ids.size !== entities.length || new Set(entities.map(e => e.tenant_id)).size > 1)
+        throw Error('brain.catalog.conflict');
+    for (const e of entities) {
+        if (e.parent_id !== null && !ids.has(e.parent_id))
+            throw Error('brain.catalog.parent-missing');
+        if (e.depends_on.some(d => !ids.has(d) || ids.get(d).parent_id !== e.parent_id))
+            throw Error('brain.catalog.dependency-invalid');
+    }
+    const visiting = new Set(), done = new Set();
+    const visit = (id) => {
+        if (visiting.has(id))
+            throw Error('brain.catalog.cycle');
+        if (done.has(id))
+            return;
+        visiting.add(id);
+        ids.get(id).depends_on.forEach(visit);
+        visiting.delete(id);
+        done.add(id);
+    };
+    entities.forEach(e => visit(e.id));
+    if (scope) {
+        const project = ids.get(scope.project_id), selected = scope.initiative_ids;
+        if (project?.kind !== 'proj' || !Array.isArray(selected) || !['project', 'initiatives'].includes(scope.delivery) ||
+            (scope.delivery === 'project' ? selected.length !== 0 : selected.length === 0) ||
+            selected.some(id => ids.get(id)?.parent_id !== project.id))
+            throw Error('brain.scope.invalid');
+    }
+    return entities;
+}

package/dist/company-brain-journal.js

@@ -0,0 +1,192 @@
+"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.bytesHash = void 0;
+exports.withProcessLock = withProcessLock;
+exports.durableAppend = durableAppend;
+exports.atomicJson = atomicJson;
+exports.readJournal = readJournal;
+exports.recoverPortfolio = recoverPortfolio;
+exports.replaceWithJournal = replaceWithJournal;
+exports.portfolioMutation = portfolioMutation;
+/** D9: journal recuperável para fontes em arquivo, sem reescrever o ledger. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const bytesHash = (v) => (0, node_crypto_1.createHash)('sha256').update(v).digest('hex');
+exports.bytesHash = bytesHash;
+function processIdentity(pid) {
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+        if (fields[0] === 'Z')
+            return null;
+        return fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim() + ':' + fields[19];
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw Error('brain.lock.identity-unavailable');
+    }
+}
+/** Bakery lock with unique contender files. Reaping never unlinks a reusable lock name.
+ * Atomic publication + ticket order exclude live writers; PID start/boot identity handles reuse.
+ * Linux process identity is required; unidentifiable legacy locks fail closed. */
+function withProcessLock(dir, busy, run) {
+    if (fs.existsSync(dir) && !fs.lstatSync(dir).isDirectory())
+        throw Error('brain.lock.recovery-required');
+    fs.mkdirSync(dir, { recursive: true });
+    const identity = processIdentity(process.pid);
+    if (!identity)
+        throw Error('brain.lock.identity-unavailable');
+    const name = (0, node_crypto_1.randomUUID)() + '.json', file = path.join(dir, name);
+    const owner = { pid: process.pid, identity, ticket: 0 };
+    const contenders = () => {
+        const result = [];
+        for (const entry of fs.readdirSync(dir).filter(n => n.endsWith('.json'))) {
+            let value;
+            try {
+                value = JSON.parse(fs.readFileSync(path.join(dir, entry), 'utf8'));
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw Error('brain.lock.corrupt');
+            }
+            if (!Number.isSafeInteger(value.pid) || value.pid < 1 || typeof value.identity !== 'string' ||
+                !Number.isSafeInteger(value.ticket) || value.ticket < 0)
+                throw Error('brain.lock.corrupt');
+            if (processIdentity(value.pid) !== value.identity) {
+                // UUID names are never reused: a concurrent reaper cannot remove a new owner.
+                try {
+                    fs.unlinkSync(path.join(dir, entry));
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+            }
+            else
+                result.push({ name: entry, ticket: value.ticket });
+        }
+        return result;
+    };
+    atomicJson(file, owner);
+    try {
+        owner.ticket = Math.max(0, ...contenders().map(c => c.ticket)) + 1;
+        atomicJson(file, owner);
+        if (contenders().some(c => c.name !== name && (c.ticket === 0 || c.ticket < owner.ticket ||
+            c.ticket === owner.ticket && c.name < name)))
+            throw Error(busy);
+        return run();
+    }
+    finally {
+        fs.unlinkSync(file);
+    }
+}
+function durableAppend(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const fd = fs.openSync(file, 'a', 0o600);
+    try {
+        fs.writeFileSync(fd, JSON.stringify(value) + '\n');
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    syncDirectory(path.dirname(file));
+}
+function syncDirectory(dir) {
+    const fd = fs.openSync(dir, 'r');
+    try {
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function atomicJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = file + '.' + (0, node_crypto_1.randomUUID)() + '.tmp';
+    const fd = fs.openSync(tmp, 'wx', 0o600);
+    try {
+        fs.writeFileSync(fd, JSON.stringify(value, null, 2) + '\n');
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    fs.renameSync(tmp, file);
+    syncDirectory(path.dirname(file));
+}
+function readJournal(file) {
+    if (!fs.existsSync(file))
+        return [];
+    const text = fs.readFileSync(file, 'utf8');
+    if (!text.endsWith('\n'))
+        throw Error('brain.journal.incomplete');
+    try {
+        return text.trimEnd().split('\n').map(l => JSON.parse(l));
+    }
+    catch {
+        throw Error('brain.journal.corrupt');
+    }
+}
+function recoverPortfolio(file) {
+    const journal = file + '.journal.jsonl', entries = readJournal(journal);
+    const finished = new Set(entries.filter(e => e.type === 'confirmed' || e.type === 'aborted').map(e => e.id));
+    for (const intent of entries.filter(e => e.type === 'intent' && !finished.has(e.id))) {
+        const current = fs.existsSync(file) ? (0, exports.bytesHash)(fs.readFileSync(file)) : null;
+        if (current !== intent.beforeHash && current !== intent.afterHash)
+            throw Error('brain.journal.source-conflict');
+        durableAppend(journal, { type: current === intent.afterHash ? 'confirmed' : 'aborted', id: intent.id, recovered: true });
+    }
+}
+function replaceWithJournal(file, value, fault = () => { }) {
+    const beforeValue = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : null;
+    const beforeHash = fs.existsSync(file) ? (0, exports.bytesHash)(fs.readFileSync(file)) : null;
+    const afterHash = (0, exports.bytesHash)(JSON.stringify(value, null, 2) + '\n'), id = (0, node_crypto_1.randomUUID)();
+    durableAppend(file + '.journal.jsonl', { schema: 'ork.brain-source-intent/v1', type: 'intent', id,
+        observedAt: new Date().toISOString(), beforeHash, afterHash, beforeValue, value });
+    fault('intent');
+    atomicJson(file, value);
+    fault('source');
+    durableAppend(file + '.journal.jsonl', { type: 'confirmed', id });
+    fault('confirmed');
+}
+function portfolioMutation(file, run) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    return withProcessLock(file + '.lock', 'brain.journal.busy', () => { recoverPortfolio(file); return run(); });
+}

package/dist/company-brain-mcp.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRAIN_WRITE_TOOLS = exports.BRAIN_READ_TOOLS = void 0;
+exports.registerBrainTools = registerBrainTools;
+const zod_1 = require("zod");
+const company_brain_cli_1 = require("./company-brain-cli");
+exports.BRAIN_READ_TOOLS = ['ork_brain_status', 'ork_brain_inventory', 'ork_brain_get', 'ork_brain_query', 'ork_brain_receipts'];
+exports.BRAIN_WRITE_TOOLS = ['ork_brain_sync', 'ork_brain_apply', 'ork_brain_rollback', 'ork_brain_bind'];
+/** Installation supplies exact grants; presence of a tool is never activation or human identity. */
+function registerBrainTools(register, load, checkThread, writeGrants = []) {
+    if (writeGrants.some(n => !exports.BRAIN_WRITE_TOOLS.includes(n)))
+        throw Error('brain.mcp.grant-invalid');
+    const id = zod_1.z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/), base = zod_1.z.object({ threadId: id }).strict();
+    const definitions = [['status', base], ['inventory', base], ['get', base.extend({ id })], ['receipts', base.extend({ id })],
+        ['query', base.extend({ ids: zod_1.z.array(id).max(1000).optional(), kinds: zod_1.z.array(zod_1.z.enum(['prod', 'proj', 'init', 'assertion'])).optional(), limit: zod_1.z.number().int().min(1).max(1000).optional() })],
+        ['sync', base], ['apply', base.extend({ plan: zod_1.z.string().min(1).max(512), expectedSha256: zod_1.z.string().regex(/^[a-f0-9]{64}$/) })],
+        ['rollback', base.extend({ batch: id })], ['bind', base.extend({ project: id, initiatives: zod_1.z.array(id).min(1).max(1000) })]];
+    for (const [operation, inputSchema] of definitions) {
+        const name = 'ork_brain_' + operation, writing = exports.BRAIN_WRITE_TOOLS.includes(name);
+        if (writing && !writeGrants.includes(name))
+            continue;
+        register(name, { description: `Company Brain ${operation}: estado e fontes pelo contrato canônico; identidade humana nunca vem de argumento.`, inputSchema: inputSchema.strict(), annotations: { readOnlyHint: !writing, destructiveHint: writing } }, async (args) => {
+            const c = load();
+            checkThread(args.threadId);
+            const options = { thread: args.threadId, json: true };
+            for (const [key, value] of Object.entries(args))
+                if (key !== 'threadId')
+                    options[key === 'expectedSha256' ? 'expected-sha256' : key] = Array.isArray(value) ? value.join(',') : String(value);
+            const result = (0, company_brain_cli_1.runBrain)(c, operation, options);
+            return { content: [{ type: 'text', text: JSON.stringify(result) }], ...(['unavailable', 'forbidden', 'conflict'].includes(result.state) ? { isError: true } : {}) };
+        });
+    }
+}

package/dist/company-brain-migration.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.brainAdmin = brainAdmin;
+exports.reconcileBrain = reconcileBrain;
+exports.applyBrain = applyBrain;
+const node_child_process_1 = require("node:child_process");
+const project_state_1 = require("./project-state");
+const portfolio_1 = require("./portfolio");
+const company_brain_source_1 = require("./company-brain-source");
+const company_brain_journal_1 = require("./company-brain-journal");
+const company_brain_contract_1 = require("./company-brain-contract");
+function brainAdmin(c) {
+    const config = (0, project_state_1.memoryState)(c).loaded.manifesto.memory;
+    return (operation, payload) => {
+        const dsn = config.database_url_env ? process.env[config.database_url_env] : undefined;
+        if (config.mode !== 'orkmind' || !dsn)
+            throw Error('brain.configuration.missing');
+        const r = (0, node_child_process_1.spawnSync)(config.cli, ['brain', 'migration'], { cwd: c.raiz, shell: false, encoding: 'utf8', timeout: Math.min(config.timeout_ms, 15000), maxBuffer: 2 * 1024 * 1024,
+            input: JSON.stringify({ schema: 'orkmind.company-brain-admin/v1', operation, payload }),
+            env: { PATH: process.env.PATH ?? '/usr/bin:/bin', PYTHONDONTWRITEBYTECODE: '1', ORKMIND_DATABASE_URL: dsn, ORKMIND_BRAIN_TENANT: config.tenant } });
+        try {
+            const response = JSON.parse(r.stdout);
+            if (r.status !== 0 || response.state !== 'ok')
+                throw Error();
+            return response.result;
+        }
+        catch {
+            throw Error('brain.migration.unconfirmed');
+        }
+    };
+}
+function reconcileBrain(c, scope, batch, transport = brainAdmin(c)) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(batch))
+        throw Error('brain.migration.batch-invalid');
+    const file = (0, project_state_1.stateFile)(c.raiz, 'portfolio.json'), before = (0, company_brain_journal_1.bytesHash)((0, company_brain_source_1.readSourceFile)(file));
+    const catalog = (0, portfolio_1.readPortfolio)(c.raiz);
+    const latest = new Map();
+    for (const entity of (0, company_brain_source_1.portfolioHistory)(catalog, scope, (0, company_brain_journal_1.readJournal)(file + '.journal.jsonl')))
+        latest.set(entity.id, entity);
+    const currentIds = new Set([...catalog.products, ...catalog.projects, ...catalog.initiatives].map(e => e.id));
+    const entities = [...latest.values()].filter(e => currentIds.has(e.id));
+    if ((0, company_brain_journal_1.bytesHash)((0, company_brain_source_1.readSourceFile)(file)) !== before)
+        throw Error('brain.migration.source-changed');
+    const plan = (0, company_brain_contract_1.validateContract)(transport('plan', { entities, batch_id: batch, source_hash: before, observed_at: catalog.updatedAt }));
+    if (plan.schema !== 'orkmind.company-brain-migration/v1' || plan.source_hash !== before || plan.tenant_id !== scope.tenant ||
+        plan.operations.length !== entities.length || new Set(plan.operations.map((o) => o.id)).size !== entities.length ||
+        entities.some(e => !plan.operations.some((o) => o.id === e.id && (0, company_brain_contract_1.digest)(o.after) === (0, company_brain_contract_1.digest)(e))))
+        throw Error('brain.migration.plan-invalid');
+    return { plan, sha256: (0, company_brain_contract_1.digest)(plan) };
+}
+function applyBrain(c, plan, expected, transport = brainAdmin(c)) {
+    const validated = (0, company_brain_contract_1.validateContract)(plan);
+    const config = (0, project_state_1.memoryState)(c).loaded.manifesto.memory;
+    if (validated.schema !== 'orkmind.company-brain-migration/v1' || validated.tenant_id !== config.tenant || (0, company_brain_contract_1.digest)(plan) !== expected)
+        throw Error('brain.migration.stale');
+    const current = (0, company_brain_journal_1.bytesHash)((0, company_brain_source_1.readSourceFile)((0, project_state_1.stateFile)(c.raiz, 'portfolio.json')));
+    if (current !== validated.source_hash)
+        throw Error('brain.migration.source-changed');
+    return transport('apply', { plan: validated, expected_hash: expected, current_source_hash: current });
+}