@orkastery/cli 0.2.0 → 0.4.1

package/dist/contrato-publico.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * I-42 (D7): fronteira dura de contrato publico.
+ *
+ * O `#Fast` e a edicao rapida, sem GOAL, PLAN nem CHECK. Mudar um contrato publico (as unioes
+ * `Fase`, `Modo` e `MotivoGate`, os contratos versionados `ork.*`, o formato do ledger e os
+ * esquemas MCP e JSON) e iniciativa por definicao: pede plano e verificacao independente. Por
+ * isso uma thread `fast` nao commita nenhum destes caminhos.
+ *
+ * A regra e por caminho, nao por simbolo, e grossa de proposito: quando erra, erra mandando a
+ * mudanca para um modo com PLAN e CHECK. A lista e contrato sobre contratos: qualquer item que
+ * entre ou saia dela precisa de ratificacao.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PATHS_DE_CONTRATO_PUBLICO = void 0;
+exports.ehContratoPublico = ehContratoPublico;
+exports.contratosTocados = contratosTocados;
+/** Domicilio unico da lista. Diretorio termina em `/`. */
+exports.PATHS_DE_CONTRATO_PUBLICO = [
+    'core/src/types.ts',
+    'core/src/modos.ts',
+    'core/src/ledger.ts',
+    'core/src/hitl-contract.ts',
+    'core/src/pulse.ts',
+    'core/src/master.ts',
+    'core/src/setup.ts',
+    'core/src/mcp-server.ts',
+    'core/src/contrato-publico.ts',
+    'core/schemas/',
+];
+/** O caminho (relativo a raiz do repositorio) e contrato publico? */
+function ehContratoPublico(caminho) {
+    const normalizado = caminho.replace(/\\/g, '/').replace(/^\.\//, '');
+    return exports.PATHS_DE_CONTRATO_PUBLICO.some((p) => (p.endsWith('/') ? normalizado.startsWith(p) : normalizado === p));
+}
+/** Os caminhos do commit que uma thread `fast` nao pode tocar. */
+function contratosTocados(caminhos) {
+    return caminhos.filter(ehContratoPublico);
+}

package/dist/creation-operation-store.js

@@ -0,0 +1,251 @@
+"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.creationOperationSchema = exports.creationStates = exports.creationRequestSchema = void 0;
+exports.withCreationLock = withCreationLock;
+exports.writeCreationJson = writeCreationJson;
+exports.readCreationOperation = readCreationOperation;
+exports.listCreationOperations = listCreationOperations;
+exports.receiveCreationOperation = receiveCreationOperation;
+exports.advanceCreationOperation = advanceCreationOperation;
+/** Durable intent journal. No portfolio, thread or runtime effects happen in this store. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const zod_1 = require("zod");
+const manifest_1 = require("./manifest");
+const modos_1 = require("./modos");
+const entityId = zod_1.z.string().regex(/^(prod|proj|init)-[a-z0-9][a-z0-9-]{2,47}$/);
+const version = zod_1.z.number().int().positive();
+const entity = zod_1.z.object({
+    kind: zod_1.z.enum(['project', 'initiative']), id: entityId,
+    parentId: entityId, title: zod_1.z.string().trim().min(1).max(160),
+    description: zod_1.z.string().max(10000).default(''),
+    acceptanceCriteria: zod_1.z.array(zod_1.z.string().trim().min(1).max(1000)).max(100),
+}).strict();
+exports.creationRequestSchema = zod_1.z.object({
+    key: zod_1.z.string().min(8).max(200),
+    action: zod_1.z.enum(['create_entity', 'create_entity_with_ticket', 'open_ticket']),
+    entity: entity.optional(), entityId: entityId.optional(),
+    expectedParentVersion: version.optional(), expectedEntityVersion: version.optional(),
+    request: zod_1.z.string().trim().min(1).max(10000),
+    doneWhen: zod_1.z.array(zod_1.z.string().trim().min(1).max(1000)).min(1).max(100),
+    workspaceIds: zod_1.z.array(zod_1.z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/)).max(30),
+    // Leitor: operacao de criacao ja persistida em modo aposentado continua parseando.
+    mode: zod_1.z.enum(modos_1.MODOS_LEGADOS),
+    scope: zod_1.z.object({ projectId: entityId, delivery: zod_1.z.enum(['project', 'initiatives']), initiativeIds: zod_1.z.array(entityId) }).strict().optional(),
+}).strict().superRefine((value, ctx) => {
+    const existing = value.action === 'open_ticket';
+    if (existing ? (!value.entityId || value.entity || !value.expectedEntityVersion) : (!value.entity || value.entityId || !value.expectedParentVersion)) {
+        ctx.addIssue({ code: 'custom', message: 'creation.input: entidade e versões incompatíveis com a ação' });
+    }
+});
+exports.creationStates = ['received', 'entity_persisted', 'ticket_persisted', 'completed', 'recoverable_failure', 'compensating', 'compensation_failed', 'compensated'];
+const state = zod_1.z.enum(exports.creationStates);
+const event = zod_1.z.object({ sequence: version, at: zod_1.z.string().datetime(), origin: zod_1.z.literal('ork.creation'), state, reason: zod_1.z.string().max(200) }).strict();
+exports.creationOperationSchema = zod_1.z.object({
+    schema: zod_1.z.literal('ork.creation-operation/v1'), operationId: zod_1.z.string().regex(/^cop-[a-f0-9]{32}$/),
+    version, principal: zod_1.z.string().min(1).max(200), requestHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+    request: exports.creationRequestSchema, state,
+    createdAt: zod_1.z.string().datetime(), updatedAt: zod_1.z.string().datetime(),
+    reserved: zod_1.z.object({ entityId, ticketId: zod_1.z.string().regex(/^obj-cop-[a-f0-9]{32}$/).nullable(), threadIds: zod_1.z.array(zod_1.z.string().regex(/^[a-z0-9]+-[a-z0-9]{1,12}$/)).max(8) }).strict(),
+    confirmed: zod_1.z.object({ entityVersion: version.nullable(), ticket: zod_1.z.boolean() }).strict(),
+    nextAction: zod_1.z.enum(['resume', 'compensate', 'none', 'manual']),
+    error: zod_1.z.object({ code: zod_1.z.string().regex(/^creation\.[a-z_]+$/), message: zod_1.z.string().max(300) }).strict().nullable(),
+    receipts: zod_1.z.array(zod_1.z.string().max(300)), events: zod_1.z.array(event).min(1),
+}).strict().superRefine((value, ctx) => {
+    if (value.events.length !== value.version || value.events.some((e, i) => e.sequence !== i + 1)
+        || value.events.at(-1)?.state !== value.state)
+        ctx.addIssue({ code: 'custom', message: 'creation.corrupt: sequência inválida' });
+    if (hash(value.request) !== value.requestHash || operationId(value.principal, value.request.key) !== value.operationId) {
+        ctx.addIssue({ code: 'custom', message: 'creation.corrupt: identidade ou intenção alterada' });
+    }
+    if (value.reserved.entityId !== (value.request.entity?.id ?? value.request.entityId)
+        || value.reserved.ticketId !== (value.request.action === 'create_entity' ? null : 'obj-' + value.operationId)
+        || (value.state === 'completed' && (!value.confirmed.entityVersion || (value.reserved.ticketId && !value.confirmed.ticket)))
+        || (['completed', 'compensated'].includes(value.state) && value.nextAction !== 'none')) {
+        ctx.addIssue({ code: 'custom', message: 'creation.corrupt: vínculos ou resultado incompatíveis' });
+    }
+});
+function canonical(value) {
+    if (Array.isArray(value))
+        return '[' + value.map(canonical).join(',') + ']';
+    if (value && typeof value === 'object')
+        return '{' + Object.entries(value).filter(([, v]) => v !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => JSON.stringify(k) + ':' + canonical(v)).join(',') + '}';
+    return JSON.stringify(value);
+}
+function hash(value) { return (0, node_crypto_1.createHash)('sha256').update(canonical(value)).digest('hex'); }
+function operationId(principal, key) { return 'cop-' + hash([principal, key]).slice(0, 32); }
+function directory(root) { return path.join((0, manifest_1.dirEstado)(root), 'creation-operations'); }
+function file(root, id) {
+    if (!/^cop-[a-f0-9]{32}$/.test(id))
+        throw new Error('creation.id: identidade inválida');
+    return path.join(directory(root), id + '.json');
+}
+function syncDirectory(dir) {
+    const fd = fs.openSync(dir, 'r');
+    try {
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function ensureDirectory(dir) {
+    if (fs.existsSync(dir))
+        return;
+    const parent = path.dirname(dir);
+    ensureDirectory(parent);
+    try {
+        fs.mkdirSync(dir, { mode: 0o700 });
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+    }
+    syncDirectory(parent);
+}
+/** Stable inode and kernel ownership: process death releases the lock without a TTL race. */
+function withCreationLock(root, name, run) {
+    if (!/^[a-z0-9-]+$/.test(name))
+        throw new Error('creation.lock: nome inválido');
+    if (process.platform !== 'linux')
+        throw new Error('runtime.unavailable: journal exige flock Linux');
+    const dir = path.join(directory(root), 'locks');
+    ensureDirectory(dir);
+    const target = path.join(dir, name);
+    const fd = fs.openSync(target, fs.constants.O_RDWR | fs.constants.O_CREAT | fs.constants.O_NOFOLLOW, 0o600);
+    try {
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || stat.nlink !== 1 || stat.uid !== process.getuid?.() || stat.mode & 0o077)
+            throw new Error('creation.lock: arquivo inseguro');
+        const result = (0, node_child_process_1.spawnSync)('/usr/bin/flock', ['--exclusive', '--timeout', '5', '3'], { stdio: ['ignore', 'pipe', 'pipe', fd], timeout: 6000 });
+        if (result.error || result.status !== 0)
+            throw new Error('creation.busy: exclusão do kernel indisponível');
+        const current = fs.lstatSync(target);
+        if (current.ino !== stat.ino || current.dev !== stat.dev || current.isSymbolicLink())
+            throw new Error('creation.lock: inode alterado');
+        return run();
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** File sync before rename, directory sync after rename. Readers see one complete revision. */
+function writeCreationJson(target, value) {
+    const dir = path.dirname(target);
+    ensureDirectory(dir);
+    const tmp = path.join(dir, '.' + path.basename(target) + '.' + (0, node_crypto_1.randomUUID)() + '.tmp');
+    try {
+        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, target);
+        syncDirectory(dir);
+    }
+    finally {
+        if (fs.existsSync(tmp))
+            fs.unlinkSync(tmp);
+    }
+}
+function readCreationOperation(root, id, principal) {
+    const value = exports.creationOperationSchema.parse(JSON.parse(fs.readFileSync(file(root, id), 'utf8')));
+    if (value.principal !== principal)
+        throw new Error('creation.unavailable: operação indisponível');
+    return value;
+}
+function listCreationOperations(root, principal) {
+    if (!fs.existsSync(directory(root)))
+        return [];
+    return fs.readdirSync(directory(root)).filter((name) => /^cop-[a-f0-9]{32}\.json$/.test(name))
+        .map((name) => exports.creationOperationSchema.parse(JSON.parse(fs.readFileSync(path.join(directory(root), name), 'utf8'))))
+        .filter((op) => op.principal === principal).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || a.operationId.localeCompare(b.operationId));
+}
+/** Caller supplies the authenticated principal out of band; a payload cannot choose it. */
+function receiveCreationOperation(root, principal, raw, abbrev) {
+    zod_1.z.string().min(1).max(200).parse(principal);
+    if (!/^[a-z][a-z0-9]{0,11}$/.test(abbrev))
+        throw new Error('creation.input: abbrev inválido');
+    const request = exports.creationRequestSchema.parse(raw);
+    const id = operationId(principal, request.key);
+    return withCreationLock(root, id, () => {
+        if (fs.existsSync(file(root, id))) {
+            const prior = readCreationOperation(root, id, principal);
+            if (prior.requestHash !== hash(request))
+                throw new Error('creation.conflict: chave reutilizada com outra intenção');
+            return prior;
+        }
+        const now = new Date().toISOString();
+        const ticket = request.action !== 'create_entity';
+        const value = {
+            schema: 'ork.creation-operation/v1', operationId: id, version: 1, principal, requestHash: hash(request), request,
+            state: 'received', createdAt: now, updatedAt: now,
+            reserved: { entityId: request.entity?.id ?? request.entityId, ticketId: ticket ? 'obj-' + id : null,
+                threadIds: ticket ? [1, 2, 3].map((n) => `${abbrev}-c${id.slice(4, 14)}${n}`) : [] },
+            confirmed: { entityVersion: null, ticket: false }, nextAction: 'resume', error: null, receipts: [],
+            events: [{ sequence: 1, at: now, origin: 'ork.creation', state: 'received', reason: 'intent.persisted' }],
+        };
+        writeCreationJson(file(root, id), exports.creationOperationSchema.parse(value));
+        return readCreationOperation(root, id, principal);
+    });
+}
+const transitions = {
+    received: ['entity_persisted', 'recoverable_failure', 'compensating'],
+    entity_persisted: ['ticket_persisted', 'completed', 'recoverable_failure', 'compensating'],
+    ticket_persisted: ['completed', 'recoverable_failure', 'compensating'],
+    completed: ['compensating'], recoverable_failure: ['entity_persisted', 'ticket_persisted', 'completed', 'recoverable_failure', 'compensating'],
+    compensating: ['compensated', 'compensation_failed'], compensation_failed: ['compensating'], compensated: [],
+};
+function advanceCreationOperation(root, id, principal, expectedVersion, change, reason) {
+    return withCreationLock(root, id, () => {
+        const prior = readCreationOperation(root, id, principal);
+        if (prior.version !== expectedVersion)
+            throw new Error('creation.conflict: revisão alterada');
+        if (!transitions[prior.state].includes(change.state))
+            throw new Error('creation.transition: transição inválida');
+        const now = new Date().toISOString();
+        const value = exports.creationOperationSchema.parse({ ...prior, ...change, version: prior.version + 1, updatedAt: now,
+            events: [...prior.events, { sequence: prior.version + 1, at: now, origin: 'ork.creation', state: change.state, reason }] });
+        writeCreationJson(file(root, id), value);
+        return readCreationOperation(root, id, principal);
+    });
+}

package/dist/creation-operation.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCreation = startCreation;
+exports.resumeCreation = resumeCreation;
+exports.compensateCreation = compensateCreation;
+const creation_operation_store_1 = require("./creation-operation-store");
+const portfolio_1 = require("./portfolio");
+const objective_1 = require("./objective");
+const thread_1 = require("./thread");
+const modos_1 = require("./modos");
+function authorize(loaded, actor, request, action) {
+    actor.authorize(request, action);
+    if (!loaded.manifesto.conduction.allowed_modes.includes(request.mode))
+        throw new Error('creation.mode: modo não autorizado pelo manifesto');
+}
+function entityConfirmed(root, op) {
+    const entity = (0, portfolio_1.findEntity)(root, op.reserved.entityId);
+    if (!entity)
+        throw new Error('creation.conflict: entidade indisponível');
+    const expected = op.request.action === 'open_ticket' ? op.request.expectedEntityVersion : 1;
+    if (entity.version !== expected || (op.request.action !== 'open_ticket' && entity.creationOperationId !== op.operationId)) {
+        throw new Error('creation.conflict: entidade alterada ou pertencente a outra operação');
+    }
+    return entity;
+}
+function scopeFor(root, op, entity) {
+    if (entity.kind === 'product')
+        throw new Error('creation.scope: ticket exige projeto ou iniciativa');
+    const projectId = entity.kind === 'project' ? entity.id : entity.projectId;
+    const scope = op.request.scope ?? { projectId, delivery: entity.kind === 'project' ? 'project' : 'initiatives', initiativeIds: entity.kind === 'initiative' ? [entity.id] : [] };
+    if (scope.projectId !== projectId || (entity.kind === 'initiative' && (scope.delivery !== 'initiatives' || !scope.initiativeIds.includes(entity.id)))) {
+        throw new Error('creation.scope: escopo não contém a entidade alvo');
+    }
+    const validated = (0, portfolio_1.assertCycleScope)(root, scope);
+    const project = (0, portfolio_1.findEntity)(root, projectId);
+    if (!project || project.kind !== 'project')
+        throw new Error('creation.scope: projeto indisponível');
+    if (op.request.workspaceIds.some((id) => !project.workspaceIds.includes(id)))
+        throw new Error('creation.scope: workspace fora do projeto');
+    return { productId: project.productId, ...validated };
+}
+function confirmTicket(root, op) {
+    const ticket = (0, objective_1.readObjective)(root, op.reserved.ticketId);
+    if (ticket.creationOrigin?.operationId !== op.operationId || ticket.creationOrigin?.requestHash !== op.requestHash
+        || ticket.creationOrigin?.ticketId !== ticket.id || ticket.envelope.request !== op.request.request
+        || JSON.stringify(ticket.threads.map((t) => t.id)) !== JSON.stringify(op.reserved.threadIds))
+        throw new Error('creation.conflict: ticket sem origem confirmada');
+    for (const id of op.reserved.threadIds) {
+        const thread = (0, thread_1.lerThread)(root, id);
+        if (thread.creationOrigin?.operationId !== op.operationId || thread.creationOrigin?.requestHash !== op.requestHash)
+            throw new Error('creation.conflict: thread sem origem confirmada');
+    }
+    return `objective:${ticket.id}:envelope:${ticket.envelope.hash}`;
+}
+function fail(root, op, error, compensation = false) {
+    const detail = error instanceof Error ? error.message : '';
+    const known = detail.match(/^creation\.(conflict|scope|mode|started|unavailable|busy):/)?.[1];
+    const code = `creation.${known ?? 'effect_failed'}`;
+    return (0, creation_operation_store_1.advanceCreationOperation)(root, op.operationId, op.principal, op.version, {
+        state: compensation ? 'compensation_failed' : 'recoverable_failure', confirmed: op.confirmed,
+        nextAction: known === 'started' ? 'manual' : compensation ? 'compensate' : 'resume',
+        error: { code, message: known === 'started' ? 'Execução ou alteração detectada; use a condução operacional.' : 'A operação foi preservada. Revalide permissões, versões e escopo antes de retomar.' }, receipts: op.receipts,
+    }, code);
+}
+function startCreation(loaded, actor, raw) {
+    const request = creation_operation_store_1.creationRequestSchema.parse(raw);
+    authorize(loaded, actor, request, 'create');
+    const op = (0, creation_operation_store_1.receiveCreationOperation)(loaded.raiz, actor.principal, request, loaded.manifesto.project.abbrev);
+    // Repetição de uma intenção que já avançou devolve o journal; recuperação é explícita.
+    return op.version > 1 ? op : resumeCreation(loaded, actor, op.operationId, op.version);
+}
+function resumeCreation(loaded, actor, id, expectedVersion) {
+    const root = loaded.raiz;
+    return (0, creation_operation_store_1.withCreationLock)(root, `effects-${id}`, () => {
+        let op = (0, creation_operation_store_1.readCreationOperation)(root, id, actor.principal);
+        authorize(loaded, actor, op.request, 'resume');
+        if (op.version !== expectedVersion)
+            throw new Error('creation.conflict: revisão alterada');
+        if (['completed', 'compensated'].includes(op.state))
+            return op;
+        if (['compensating', 'compensation_failed'].includes(op.state))
+            throw new Error('creation.conflict: retome a compensação');
+        const advance = (state, entityVersion, ticket, receipts) => {
+            op = (0, creation_operation_store_1.advanceCreationOperation)(root, id, actor.principal, op.version, { state, confirmed: { entityVersion, ticket }, nextAction: state === 'completed' ? 'none' : 'resume', error: null, receipts }, `${state}.confirmed`);
+        };
+        try {
+            if (op.request.action !== 'open_ticket')
+                (0, portfolio_1.createOperationEntity)(root, id, actor.principal);
+            let entity = entityConfirmed(root, op);
+            if (op.state === 'received' || op.state === 'recoverable_failure')
+                advance('entity_persisted', entity.version, op.confirmed.ticket, op.receipts);
+            if (op.reserved.ticketId) {
+                authorize(loaded, actor, op.request, 'resume');
+                entity = entityConfirmed(root, op);
+                const scope = scopeFor(root, op, entity);
+                if (op.state !== 'ticket_persisted') {
+                    // Leitor: a operacao durável pode ter sido gravada em modo aposentado; ela
+                    // continua parseando, e so nao pode mais ABRIR thread nova nesse modo.
+                    const modoVivo = (0, modos_1.parseModo)(op.request.mode);
+                    if (!modoVivo)
+                        throw new Error(`creation.mode: modo aposentado "${op.request.mode}" nao abre thread nova`);
+                    (0, objective_1.createReservedObjective)(loaded, { title: entity.title, request: op.request.request, doneWhen: op.request.doneWhen, mode: modoVivo, ...scope }, { operationId: id, principal: actor.principal });
+                    const receipt = confirmTicket(root, op);
+                    advance('ticket_persisted', entity.version, true, [...new Set([...op.receipts, receipt])]);
+                }
+                confirmTicket(root, op);
+            }
+            entity = entityConfirmed(root, op);
+            advance('completed', entity.version, Boolean(op.reserved.ticketId), op.receipts);
+            return (0, creation_operation_store_1.readCreationOperation)(root, id, actor.principal);
+        }
+        catch (error) {
+            // A gravação pode ter sucedido antes da perda da resposta; releia a revisão real.
+            op = (0, creation_operation_store_1.readCreationOperation)(root, id, actor.principal);
+            if (op.state === 'completed')
+                return op;
+            return fail(root, op, error);
+        }
+    });
+}
+function compensateCreation(loaded, actor, id, expectedVersion) {
+    const root = loaded.raiz;
+    return (0, creation_operation_store_1.withCreationLock)(root, `effects-${id}`, () => {
+        let op = (0, creation_operation_store_1.readCreationOperation)(root, id, actor.principal);
+        authorize(loaded, actor, op.request, 'compensate');
+        if (op.version !== expectedVersion)
+            throw new Error('creation.conflict: revisão alterada');
+        if (op.state === 'compensated')
+            return op;
+        if (op.state !== 'compensating')
+            op = (0, creation_operation_store_1.advanceCreationOperation)(root, id, actor.principal, op.version, { state: 'compensating', confirmed: op.confirmed, nextAction: 'compensate', error: null, receipts: op.receipts }, 'compensation.requested');
+        try {
+            // Conserva entidade preexistente e efeitos próprios; nunca remove catálogo.
+            const entity = (0, portfolio_1.findEntity)(root, op.reserved.entityId);
+            if (entity)
+                entityConfirmed(root, op);
+            (0, objective_1.compensateReservedObjective)(root, id, actor.principal);
+            op = (0, creation_operation_store_1.advanceCreationOperation)(root, id, actor.principal, op.version, { state: 'compensated', confirmed: op.confirmed, nextAction: 'none', error: null, receipts: op.receipts }, 'compensation.confirmed');
+            return (0, creation_operation_store_1.readCreationOperation)(root, id, actor.principal);
+        }
+        catch (error) {
+            op = (0, creation_operation_store_1.readCreationOperation)(root, id, actor.principal);
+            if (op.state === 'compensated')
+                return op;
+            return fail(root, op, error, true);
+        }
+    });
+}

package/dist/decisao-autonoma.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOMES_HISTORICOS_DE_EVIDENCIA = exports.NOMES_HISTORICOS_DE_RAZAO = exports.NOMES_HISTORICOS_DE_QUEM = exports.LIMIAR_DE_DECISOES_POR_FASE = exports.CONTRATO_DECISAO_AUTONOMA = void 0;
+exports.rastroDaDecisao = rastroDaDecisao;
+exports.registrarDecisao = registrarDecisao;
+exports.placarDaThread = placarDaThread;
+exports.taxaDeReversao = taxaDeReversao;
+exports.decisoesParaODono = decisoesParaODono;
+/**
+ * I-41 (GO-FIX 1, B4): a metade que presta contas.
+ *
+ * Das cinco camadas que o GOAL prometeu contra "obvia virar desculpa para decidir tudo em
+ * silencio" (R1), tres estavam de pe (criterio resolvivel, preco declarado e porta fechada para o
+ * irreversivel) e duas nao existiam: o RASTRO TIPADO e o PLACAR. E nada emitia `classe: decidido`.
+ * A fabrica ja decide sessenta vezes para cada vez que pergunta (M7 do PLAN), e o dono nao via
+ * nenhuma dessas decisoes. A cobranca dele foi literal: "eu devo ser informado da decisao pra
+ * poder ajustar". Trocar burocracia por silencio seria pior que o problema original.
+ *
+ * Este modulo e o domicilio das duas camadas que faltavam, e do emissor:
+ *
+ *   RASTRO (D11). Toda `autonomous_decision` nova carrega `quemDecidiu`, `evidencia` e `razao`, e
+ *   o registro recusa o evento sem os tres (`ledger.ts`). Os nomes historicos continuam lidos,
+ *   normalizados na leitura; nenhuma linha do ledger e reescrita.
+ *
+ *   EMISSOR. `registrarDecisao` grava a decisao informada, `classe: decidido` com os quatro campos
+ *   (o que, o porque, como mudar, custo de reverter agora e depois) e o criterio que RESOLVE, no
+ *   mesmo evento do rastro. Ela nao segura fase, nao tem prazo e nao pede resposta: chega ao dono
+ *   no resumo do pulse, para ele saber e poder ajustar.
+ *
+ *   PLACAR. Por fase: decididas contra perguntas, quantas decisoes o dono mandou reverter, e
+ *   quantas vieram sem rastro. O limiar de revisao e 13 decisoes por fase, o p90 das 155 fases
+ *   medidas no PLAN (M7). Ele dispara revisao no CHECK, nunca recusa: ha fases legitimas com 81.
+ *   A taxa de reversao e o sinal que o limiar sozinho nao ve: trinta decisoes certas e trinta
+ *   erradas fazem o mesmo placar, e so a reversao diz qual das duas "obvia" era para quem le.
+ */
+const node_crypto_1 = require("node:crypto");
+const hitl_contract_1 = require("./hitl-contract");
+const hitl_gates_1 = require("./hitl-gates");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+const modos_1 = require("./modos");
+exports.CONTRATO_DECISAO_AUTONOMA = 'ork.decisao-autonoma/v1';
+/** D3/M7: o p90 das 155 fases ja medidas. Acima disso a fase esta no decil mais alto do projeto. */
+exports.LIMIAR_DE_DECISOES_POR_FASE = 13;
+/** Os nomes que o rastro teve antes de ser tipado (M6), na ordem em que valem na leitura. */
+exports.NOMES_HISTORICOS_DE_QUEM = ['quemDecidiu', 'autorizadoPor', 'quem', 'por', 'decididoPor', 'decisor',
+    'decididaPor', 'decidiuQuem'];
+exports.NOMES_HISTORICOS_DE_RAZAO = ['razao', 'porque', 'motivo', 'justificativa'];
+exports.NOMES_HISTORICOS_DE_EVIDENCIA = ['evidencia', 'evidencias', 'evidenciaSha256', 'comandos', 'sha256'];
+const valor = (e, nomes) => {
+    for (const nome of nomes) {
+        const v = e[nome];
+        const texto = Array.isArray(v) ? v.join('; ') : typeof v === 'string' || typeof v === 'number' ? String(v) : '';
+        if (texto.trim())
+            return texto.trim();
+    }
+    return undefined;
+};
+/**
+ * O rastro de uma decisao, com os nomes historicos normalizados. `tipada` diz se o evento ja nasceu
+ * com os tres campos de nome unico; um evento antigo pode ser completo pelos nomes velhos sem ser
+ * tipado, e a auditoria precisa enxergar as duas coisas.
+ */
+function rastroDaDecisao(e) {
+    const bruto = e;
+    const quemDecidiu = valor(bruto, exports.NOMES_HISTORICOS_DE_QUEM);
+    const razao = valor(bruto, exports.NOMES_HISTORICOS_DE_RAZAO);
+    const evidencia = valor(bruto, exports.NOMES_HISTORICOS_DE_EVIDENCIA);
+    const tipada = ['quemDecidiu', 'evidencia', 'razao'].every(c => typeof bruto[c] === 'string' && !!String(bruto[c]).trim());
+    return { quemDecidiu, razao, evidencia, tipada, completa: !!(quemDecidiu && razao && evidencia) };
+}
+/**
+ * O emissor de `classe: decidido`.
+ *
+ * A decisao so existe se passar pelo contrato v2 (os quatro campos, sem campo de gate, nunca
+ * irreversivel) e se o criterio RESOLVER: manifesto e ledger sao lidos de verdade, medicao tem a
+ * forma conferida e a execucao fica com o CHECK. O rastro e gravado no mesmo evento, sob o lock da
+ * thread: nao existe decisao informada sem rastro, nem rastro de uma decisao que nao chegou ao dono.
+ */
+function registrarDecisao(raiz, threadId, entrada) {
+    const t = (0, thread_1.lerThread)(raiz, threadId);
+    if (t.status === 'fechada')
+        throw new Error('decisão informada: thread fechada não decide mais nada');
+    const quando = entrada.quando ?? new Date().toISOString();
+    // I-43: thread em modo aposentado e lida para sempre, mas nao escreve pedido novo.
+    const modo = (0, modos_1.exigirModoVivo)(t.modo);
+    const pedido = {
+        contrato: hitl_contract_1.CONTRATO_HITL_V2, classe: 'decidido', id: (0, node_crypto_1.randomUUID)(), thread: t.id, fase: t.faseAtual, modo,
+        criadoEm: quando, profundidade: (0, hitl_contract_1.profundidadeDoPedido)(t.faseAtual, modo),
+        decidido: entrada.decidido, porque: entrada.porque, comoMudar: entrada.comoMudar,
+        custoDeReverter: { agora: entrada.custoDeReverter.agora, depois: entrada.custoDeReverter.depois },
+        criterio: { tipo: entrada.criterio.tipo, referencia: entrada.criterio.referencia },
+    };
+    (0, hitl_contract_1.validarPedidoHitlV2)(pedido);
+    // R1, camada 1: criterio que aponta para nada vale o mesmo que criterio ausente.
+    const { resolve, detalhe } = (0, hitl_gates_1.resolverCriterio)(raiz, pedido);
+    if (!resolve)
+        throw new Error(`decisão informada: critério não resolve (${detalhe})`);
+    const rastro = { quemDecidiu: entrada.quemDecidiu, evidencia: entrada.evidencia, razao: entrada.razao ?? entrada.porque };
+    // O registro confere os tres de novo; conferir aqui evita tomar o lock para recusar.
+    (0, ledger_1.exigirRastroDeDecisaoAutonoma)(rastro);
+    return (0, hitl_gates_1.comLockHitl)(raiz, t.id, () => {
+        const agora = (0, thread_1.lerThread)(raiz, t.id), dir = (0, thread_1.dirThread)(raiz, t.id);
+        if (agora.status === 'fechada' || agora.faseAtual !== pedido.fase)
+            throw new Error('decisão informada: a fase mudou enquanto ela era registrada');
+        if (entrada.reverte && !(0, ledger_1.lerLedger)(dir).some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma &&
+            e.pedido?.id === entrada.reverte)) {
+            throw new Error('decisão informada: a decisão revertida não existe nesta thread');
+        }
+        const evento = (0, ledger_1.registrar)(dir, t.id, ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma, {
+            contratoDecisao: exports.CONTRATO_DECISAO_AUTONOMA, fase: pedido.fase, decisao: pedido.decidido, ...rastro,
+            pedido, ...(entrada.reverte ? { reverte: entrada.reverte } : {}),
+        });
+        return { pedido, evento };
+    });
+}
+function placarDaThread(eventos) {
+    const fases = new Map();
+    const da = (fase) => {
+        const chave = typeof fase === 'string' && fase ? fase : 'sem-fase';
+        if (!fases.has(chave))
+            fases.set(chave, { fase: chave, decididas: 0, informadas: 0, perguntas: 0, revertidas: 0, semRastro: 0, acimaDoLimiar: false });
+        return fases.get(chave);
+    };
+    const revertidos = new Set(eventos.filter(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma && typeof e.reverte === 'string')
+        .map(e => String(e.reverte)));
+    for (const e of eventos) {
+        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma) {
+            const p = da(e.fase);
+            p.decididas++;
+            const id = e.pedido?.id;
+            if (id)
+                p.informadas++;
+            if (id && revertidos.has(id))
+                p.revertidas++;
+            if (!rastroDaDecisao(e).completa)
+                p.semRastro++;
+        }
+        else if (e.tipo === 'hitl_requested' && e.pedido && (0, hitl_contract_1.alvoDoPedido)(e.pedido)) {
+            da(e.fase ?? e.pedido.fase).perguntas++;
+        }
+    }
+    for (const p of fases.values())
+        p.acimaDoLimiar = p.decididas > exports.LIMIAR_DE_DECISOES_POR_FASE;
+    return [...fases.values()];
+}
+/** A taxa de reversao das decisoes informadas: o sinal de "obvia" que nao era obvia para o dono. */
+function taxaDeReversao(placar) {
+    const informadas = placar.reduce((n, p) => n + p.informadas, 0);
+    return informadas ? placar.reduce((n, p) => n + p.revertidas, 0) / informadas : null;
+}
+/**
+ * As decisoes informadas recentes de todas as threads abertas, e as fases que passaram do
+ * limiar. Somente leitura. Thread fechada nao registra decisao nova, entao nao precisa ser lida.
+ */
+function decisoesParaODono(raiz, desde) {
+    const decisoes = [], acimaDoLimiar = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        let t;
+        try {
+            t = (0, thread_1.lerThread)(raiz, id);
+        }
+        catch {
+            continue;
+        }
+        if (t.status === 'fechada')
+            continue;
+        const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
+        for (const e of eventos) {
+            const p = e.pedido;
+            if (e.tipo !== ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma || p?.classe !== 'decidido' || e.ts < desde)
+                continue;
+            decisoes.push({ id: p.id, thread: id, fase: p.fase, em: e.ts, decidido: p.decidido, porque: p.porque,
+                comoMudar: p.comoMudar, custoDeReverter: p.custoDeReverter, quemDecidiu: String(e.quemDecidiu ?? ''),
+                ...(typeof e.reverte === 'string' ? { reverte: e.reverte } : {}) });
+        }
+        const atual = placarDaThread(eventos).find(f => f.fase === t.faseAtual);
+        if (atual?.acimaDoLimiar)
+            acimaDoLimiar.push({ thread: id, fase: atual.fase, decididas: atual.decididas });
+    }
+    decisoes.sort((a, b) => a.em.localeCompare(b.em));
+    return { decisoes, acimaDoLimiar };
+}