@orkastery/cli 0.2.0 → 0.3.0

package/dist/objective.js

@@ -0,0 +1,449 @@
+"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.readObjective = readObjective;
+exports.listObjectives = listObjectives;
+exports.listObjectiveMessages = listObjectiveMessages;
+exports.messageObjective = messageObjective;
+exports.createObjective = createObjective;
+exports.createReservedObjective = createReservedObjective;
+exports.approveObjective = approveObjective;
+exports.reviseObjective = reviseObjective;
+exports.validateObjective = validateObjective;
+exports.stopObjective = stopObjective;
+exports.compensateReservedObjective = compensateReservedObjective;
+exports.objectivePhases = objectivePhases;
+exports.objectiveText = objectiveText;
+/**
+ * Maestro Mode B7: objetivos duráveis acima de uma única thread.
+ *
+ * I-43 (T11): O COMANDO `ork objective` FOI APOSENTADO. Este módulo continua aqui, e
+ * a razão está escrita abaixo porque ela é exatamente o tipo de coisa que, sem estar
+ * escrita, vira "sobrou um arquivo morto".
+ *
+ * O que SAIU, que é o que o GOAL pediu: a superfície de produto. `ork objective` em
+ * qualquer subcomando devolve `objective.aposentado` com saída != 0; o ramo de
+ * `phase.ts` que consultava o envelope no despacho saiu; e `fx-objective-oscillation`
+ * saiu junto com o mecanismo que ele exercitava (D9).
+ *
+ * O que FICOU, e por quê: este arquivo é carregado por três consumidores que NÃO são
+ * o envelope e que esta thread não tem escopo para remover:
+ *   - `creation-operation.ts`, o journal durável de criação (portfolio/creation);
+ *   - `portfolio-context.ts`, que alimenta `ork portfolio inspect`;
+ *   - `maestro-sources.ts`, que lê `objective.json` para o snapshot do Maestro.
+ * Arrancar o módulo levaria os três junto, e nenhum deles é uma das cinco remoções.
+ * O item está no roadmap com esta medida, em vez de virar uma remoção no escuro.
+ *
+ * As DUAS VIGAS que o envelope guardava saíram VIVAS, como propriedade de thread
+ * comum, e é o que torna a remoção da superfície honesta:
+ *   - validação por runtime diferente -> `thread.exigeRuntimeDiferente` (T9);
+ *   - `doneWhen` executável -> `thread.doneWhen`, que vira claim do núcleo (T10).
+ *
+ * Os envelopes já gravados em `.orkastery/objectives/` ficam em disco, intocados: é
+ * estado, e estado pertence ao núcleo. Contrato `ork.objective/v1`, um arquivo
+ * `objective.json` por diretório, legível por `cat` e `jq`.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const manifest_1 = require("./manifest");
+const slug_1 = require("./slug");
+const thread_1 = require("./thread");
+const ledger_1 = require("./ledger");
+const util_1 = require("./util");
+const types_1 = require("./types");
+const sessoes_1 = require("./sessoes");
+const portfolio_1 = require("./portfolio");
+const creation_operation_store_1 = require("./creation-operation-store");
+const hitl_gates_1 = require("./hitl-gates");
+const maestro_authority_1 = require("./maestro-authority");
+const OBJECTIVE_ID = /^obj-[a-z0-9-]{1,48}$/;
+const clean = (values) => (values ?? []).map((v) => v.trim()).filter(Boolean);
+function objectiveDir(root) { return path.join((0, manifest_1.dirEstado)(root), 'objectives'); }
+function objectiveFile(root, id) {
+    if (!OBJECTIVE_ID.test(id))
+        throw new Error('objective id inválido');
+    return path.join(objectiveDir(root), id, 'objective.json');
+}
+function messagesFile(root, id) {
+    return path.join(path.dirname(objectiveFile(root, id)), 'messages.jsonl');
+}
+function digest(value) {
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function envelope(input, version = 1, root) {
+    const maxThreads = input.maxThreads ?? 3;
+    if (!Number.isInteger(maxThreads) || maxThreads < 1 || maxThreads > 8)
+        throw new Error('maxThreads deve estar entre 1 e 8');
+    const executionRuntime = input.executionRuntime?.trim() || 'claude-bg';
+    const validationRuntimes = [...new Set(clean(input.validationRuntimes).length ? clean(input.validationRuntimes) : ['codex', 'claude-bg'])];
+    if (input.independence !== undefined && input.independence !== 'sessions')
+        throw Error('maestro.authority.mode');
+    if (input.independence === 'sessions')
+        validationRuntimes.forEach(maestro_authority_1.requireSessionReviewRuntime);
+    if (!input.independence && validationRuntimes.length < 2)
+        throw new Error('ensemble exige ao menos dois runtimes de validação');
+    if (!input.independence && !validationRuntimes.some((runtime) => runtime !== executionRuntime))
+        throw new Error('CHECK deve incluir runtime diferente do GO');
+    const base = {
+        schema: 'ork.objective-envelope/v1',
+        version,
+        request: input.request.trim(),
+        outcomes: clean(input.outcomes),
+        constraints: clean(input.constraints),
+        doneWhen: clean(input.doneWhen),
+        maxThreads,
+        executionRuntime,
+        validationRuntimes,
+        ...(input.independence ? { independence: input.independence } : {}),
+        portfolio: input.productId && input.projectId
+            ? { productId: input.productId, projectId: input.projectId, delivery: input.delivery ?? 'project', initiativeIds: clean(input.initiativeIds) }
+            : null,
+    };
+    if (!base.request)
+        throw new Error('objective exige request');
+    if (!base.doneWhen.length)
+        throw new Error('objective exige ao menos um critério de pronto');
+    if ((input.productId && !input.projectId) || (!input.productId && input.projectId))
+        throw new Error('vínculo de portfólio exige productId e projectId');
+    if (base.portfolio && root) {
+        const scope = (0, portfolio_1.assertCycleScope)(root, base.portfolio);
+        const project = (0, portfolio_1.findEntity)(root, scope.projectId);
+        if (!project || project.kind !== 'project' || project.productId !== base.portfolio.productId)
+            throw new Error('projeto não pertence ao produto informado');
+        base.portfolio = { productId: base.portfolio.productId, ...scope };
+    }
+    return { ...base, hash: digest(base) };
+}
+function persist(root, objective) {
+    objective.updatedAt = (0, util_1.agora)();
+    (0, creation_operation_store_1.writeCreationJson)(objectiveFile(root, objective.id), objective);
+    return objective;
+}
+function readObjective(root, id) {
+    const file = objectiveFile(root, id);
+    if (!fs.existsSync(file))
+        throw new Error(`objective ${id} não encontrado`);
+    const value = (0, util_1.lerJson)(file);
+    const { hash: _hash, ...body } = value.envelope;
+    if (value.schema !== 'ork.objective/v1' || digest(body) !== value.envelope.hash)
+        throw new Error('Objective Envelope inválido ou alterado fora do ork');
+    return value;
+}
+function listObjectives(root) {
+    const dir = objectiveDir(root);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => readObjective(root, e.name))
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+function listObjectiveMessages(root, id) {
+    readObjective(root, id);
+    const file = messagesFile(root, id);
+    if (!fs.existsSync(file))
+        return [];
+    return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map((line) => JSON.parse(line));
+}
+function messageObjective(root, id, input) {
+    readObjective(root, id);
+    const text = input.text.trim(), by = input.by.trim();
+    if (!text || text.length > 10_000)
+        throw new Error('mensagem deve ter entre 1 e 10000 caracteres');
+    if (!by || by.length > 120)
+        throw new Error('mensagem exige autor válido');
+    const createdAt = (0, util_1.agora)();
+    const message = {
+        schema: 'ork.objective-message/v1',
+        id: `msg-${(0, node_crypto_1.createHash)('sha256').update(`${id}:${createdAt}:${by}:${text}`).digest('hex').slice(0, 16)}`,
+        objectiveId: id, role: input.role, by, text, createdAt,
+    };
+    fs.appendFileSync(messagesFile(root, id), `${JSON.stringify(message)}\n`, { encoding: 'utf8', mode: 0o600 });
+    return message;
+}
+function createObjective(loaded, input) {
+    return (0, creation_operation_store_1.withCreationLock)(loaded.raiz, 'objectives', () => createLegacyObjective(loaded, input));
+}
+function createLegacyObjective(loaded, input) {
+    const subject = (0, slug_1.normalizarAssunto)(input.title);
+    if (!subject)
+        throw new Error('título não produz id válido');
+    let id = `obj-${subject}`, suffix = 1;
+    while (fs.existsSync(objectiveFile(loaded.raiz, id)))
+        id = `obj-${subject.slice(0, 40)}-${++suffix}`;
+    const env = envelope(input, 1, loaded.raiz);
+    const roles = ['discovery', 'delivery', 'validation'];
+    const threads = Array.from({ length: env.maxThreads }, (_, index) => {
+        const role = roles[index] ?? 'delivery';
+        const result = (0, thread_1.novaThread)(loaded, { nome: `${input.title} · ${role} ${index + 1}`, modo: input.mode ?? 'maestro', assunto: `${subject.slice(0, 8)}${index + 1}` });
+        return { id: result.thread.id, role };
+    });
+    const now = (0, util_1.agora)();
+    const value = {
+        schema: 'ork.objective/v1', id, title: input.title.trim(), mode: input.mode ?? 'maestro', status: 'awaiting_approval',
+        createdAt: now, updatedAt: now, envelope: env, envelopeHistory: [], threads, approval: null,
+        validations: [], revisions: 0, pauseReason: 'human.approval.objective-envelope', stopStack: [],
+    };
+    persist(loaded.raiz, value);
+    const dir = path.dirname(objectiveFile(loaded.raiz, id));
+    fs.writeFileSync(path.join(dir, 'INTENT.md'), input.request.trim() + '\n', 'utf8');
+    fs.writeFileSync(path.join(dir, 'SPEC.md'), `# ${input.title.trim()}\n\n## Pronto quando\n${env.doneWhen.map((x) => `- ${x}`).join('\n')}\n`, 'utf8');
+    messageObjective(loaded.raiz, id, { role: 'human', by: 'maestro', text: input.request });
+    return value;
+}
+/** Ticket determinístico fica localizável antes de qualquer thread; nunca despacha runtime. */
+function createReservedObjective(loaded, input, reservation) {
+    return (0, creation_operation_store_1.withCreationLock)(loaded.raiz, 'objectives', () => {
+        const op = (0, creation_operation_store_1.readCreationOperation)(loaded.raiz, reservation.operationId, reservation.principal);
+        const id = op.reserved.ticketId;
+        if (!id || ['compensating', 'compensated', 'compensation_failed'].includes(op.state)
+            || input.request.trim() !== op.request.request || input.mode !== op.request.mode
+            || JSON.stringify(clean(input.doneWhen)) !== JSON.stringify(op.request.doneWhen)) {
+            throw new Error('creation.conflict: ticket incompatível com intenção reservada');
+        }
+        const env = envelope(input, 1, loaded.raiz);
+        if (env.maxThreads !== op.reserved.threadIds.length)
+            throw new Error('creation.conflict: quantidade de threads não reservada');
+        const origin = { operationId: op.operationId, ticketId: id, requestHash: op.requestHash };
+        const roles = ['discovery', 'delivery', 'validation'];
+        const threads = op.reserved.threadIds.map((threadId, index) => ({ id: threadId, role: roles[index] ?? 'delivery' }));
+        let value;
+        if (fs.existsSync(objectiveFile(loaded.raiz, id))) {
+            value = readObjective(loaded.raiz, id);
+            if (value.creationOrigin?.operationId !== origin.operationId || value.creationOrigin?.requestHash !== origin.requestHash
+                || value.creationOrigin?.ticketId !== id || value.envelope.hash !== env.hash
+                || value.title !== input.title.trim() || value.mode !== input.mode || JSON.stringify(value.threads) !== JSON.stringify(threads)) {
+                throw new Error('creation.conflict: ticket reservado pertence a outra intenção ou foi revisado');
+            }
+            if (value.status !== 'awaiting_approval' || value.approval)
+                throw new Error('creation.started: ticket já saiu da criação');
+        }
+        else {
+            const now = (0, util_1.agora)();
+            value = { schema: 'ork.objective/v1', id, title: input.title.trim(), mode: input.mode, status: 'awaiting_approval',
+                createdAt: now, updatedAt: now, envelope: env, envelopeHistory: [], threads, approval: null,
+                validations: [], revisions: 0, pauseReason: 'human.approval.objective-envelope', stopStack: [], creationOrigin: origin };
+            persist(loaded.raiz, value);
+        }
+        for (const link of threads) {
+            if (fs.existsSync((0, thread_1.caminhoThread)(loaded.raiz, link.id))) {
+                const thread = (0, thread_1.lerThread)(loaded.raiz, link.id);
+                if (thread.sessoes.length || thread.decisoes.length || thread.faseAtual !== thread.fases[0] || thread.status !== 'aberta') {
+                    throw new Error('creation.started: thread já iniciou execução');
+                }
+            }
+        }
+        for (const [index, link] of threads.entries()) {
+            (0, thread_1.novaThread)(loaded, { nome: `${value.title} · ${link.role} ${index + 1}`, modo: value.mode,
+                reservation: { ...reservation, threadId: link.id } });
+        }
+        const dir = path.dirname(objectiveFile(loaded.raiz, id));
+        if (!fs.existsSync(path.join(dir, 'INTENT.md')))
+            fs.writeFileSync(path.join(dir, 'INTENT.md'), input.request.trim() + '\n', { flag: 'wx', mode: 0o600 });
+        if (!fs.existsSync(path.join(dir, 'SPEC.md')))
+            fs.writeFileSync(path.join(dir, 'SPEC.md'), `# ${value.title}\n\n## Pronto quando\n${env.doneWhen.map((x) => `- ${x}`).join('\n')}\n`, { flag: 'wx', mode: 0o600 });
+        if (!listObjectiveMessages(loaded.raiz, id).some((message) => message.role === 'ork' && message.by === 'ork.creation')) {
+            messageObjective(loaded.raiz, id, { role: 'ork', by: 'ork.creation', text: input.request });
+        }
+        // A confirmação depende de leituras dos efeitos, não da passagem pelo loop.
+        for (const link of threads) {
+            const thread = (0, thread_1.lerThread)(loaded.raiz, link.id);
+            if (thread.creationOrigin?.operationId !== op.operationId || thread.creationOrigin?.requestHash !== op.requestHash) {
+                throw new Error('creation.conflict: confirmação da thread falhou');
+            }
+        }
+        return readObjective(loaded.raiz, id);
+    });
+}
+function approveObjective(root, id, by) {
+    return (0, creation_operation_store_1.withCreationLock)(root, 'objectives', () => approveObjectiveLocked(root, id, by));
+}
+function approveObjectiveLocked(root, id, by) {
+    const value = readObjective(root, id);
+    if (!by.trim())
+        throw new Error('aprovação exige --por');
+    if (value.status !== 'awaiting_approval')
+        throw new Error(`objective não aguarda aprovação: ${value.status}`);
+    value.approval = { by: by.trim(), at: (0, util_1.agora)(), envelopeHash: value.envelope.hash };
+    if (value.envelope.independence === 'sessions')
+        for (const thread of value.threads) {
+            (0, ledger_1.registrar)((0, thread_1.dirThread)(root, thread.id), thread.id, 'objective_envelope_approved', {
+                objectiveId: id, envelopeHash: value.envelope.hash, version: value.envelope.version,
+                approvedAt: value.approval.at, by: value.approval.by,
+            });
+        }
+    value.status = 'running';
+    value.pauseReason = null;
+    return persist(root, value);
+}
+function reviseObjective(root, id, request, doneWhen) {
+    return (0, creation_operation_store_1.withCreationLock)(root, 'objectives', () => reviseObjectiveLocked(root, id, request, doneWhen));
+}
+function reviseObjectiveLocked(root, id, request, doneWhen) {
+    const value = readObjective(root, id);
+    if (!request.trim())
+        throw new Error('revisão exige request');
+    value.envelopeHistory.push(value.envelope);
+    value.revisions += 1;
+    value.envelope = envelope({
+        title: value.title, request, mode: value.mode, outcomes: value.envelope.outcomes, constraints: value.envelope.constraints,
+        doneWhen: clean(doneWhen).length ? doneWhen : value.envelope.doneWhen, maxThreads: value.envelope.maxThreads,
+        executionRuntime: value.envelope.executionRuntime, validationRuntimes: value.envelope.validationRuntimes,
+        independence: value.envelope.independence,
+        productId: value.envelope.portfolio?.productId, projectId: value.envelope.portfolio?.projectId,
+        delivery: value.envelope.portfolio?.delivery, initiativeIds: value.envelope.portfolio?.initiativeIds,
+    }, value.envelope.version + 1, root);
+    value.approval = null;
+    value.validations = [];
+    value.status = value.revisions >= 3 ? 'paused' : 'awaiting_approval';
+    value.pauseReason = value.revisions >= 3 ? 'objective.oscillation' : 'human.approval.objective-envelope';
+    return persist(root, value);
+}
+function validateObjective(root, id, runtime, verdict, evidence, binding) {
+    return (0, creation_operation_store_1.withCreationLock)(root, 'objectives', () => validateObjectiveLocked(root, id, runtime, verdict, evidence, binding));
+}
+function validateObjectiveLocked(root, id, runtime, verdict, evidence, binding) {
+    const value = readObjective(root, id);
+    if (!['running', 'validated'].includes(value.status))
+        throw new Error(`objective não está em validação: ${value.status}`);
+    if (!value.envelope.validationRuntimes.includes(runtime))
+        throw new Error('runtime fora do ensemble fixado no envelope');
+    if (!evidence.trim())
+        throw new Error('validação exige evidência');
+    let identity;
+    if (value.envelope.independence === 'sessions') {
+        if (!binding)
+            throw Error('maestro.authority.unproven');
+        if (!value.approval || value.approval.envelopeHash !== value.envelope.hash)
+            throw Error('maestro.authority.envelope-stale');
+        const currentEnvelope = { objectiveId: id, hash: value.envelope.hash, version: value.envelope.version, approvedAt: value.approval.at };
+        const proved = (0, maestro_authority_1.verifyCompletedSessionReview)(root, binding, currentEnvelope, verdict);
+        // No envelope de uma thread, discovery também hospeda GO/CHECK. Os papéis de
+        // autoridade continuam separados pelas três sessões provadas, sem migrar o envelope.
+        const singleThread = value.envelope.maxThreads === 1 && value.threads.length === 1;
+        if (proved.runtime !== runtime || !value.threads.some(t => t.id === proved.executor.threadId && (t.role === 'delivery' || singleThread)) ||
+            !value.threads.some(t => t.id === proved.conductor.threadId))
+            throw Error('maestro.authority.scope');
+        identity = proved;
+        // Um voto de outro runtime também precisa continuar vinculado à execução
+        // e ao envelope atuais antes de compor o ensemble.
+        value.validations = value.validations.filter(v => {
+            const previous = v.identity;
+            if (!previous || JSON.stringify(previous.envelope) !== JSON.stringify(currentEnvelope))
+                return false;
+            try {
+                (0, maestro_authority_1.verifyCompletedSessionReview)(root, { conductor: previous.conductor, executor: previous.executor,
+                    reviewer: previous.reviewer }, currentEnvelope, v.verdict);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    value.validations = value.validations.filter((item) => item.runtime !== runtime);
+    value.validations.push({ runtime, verdict, evidence: evidence.trim(), at: (0, util_1.agora)(), ...(identity ? { identity } : {}) });
+    const complete = value.envelope.validationRuntimes.every((expected) => value.validations.some((item) => item.runtime === expected && item.verdict === 'approved'));
+    value.status = complete ? 'validated' : verdict === 'rejected' ? 'paused' : 'running';
+    value.pauseReason = verdict === 'rejected' ? 'ensemble.rejected' : null;
+    return persist(root, value);
+}
+function stopObjective(root, id, stop = sessoes_1.pararSessao) {
+    return (0, creation_operation_store_1.withCreationLock)(root, 'objectives', () => stopObjectiveLocked(root, id, stop));
+}
+function stopObjectiveLocked(root, id, stop) {
+    const value = readObjective(root, id);
+    if (value.status === 'stopped')
+        return value;
+    value.stopStack = [];
+    for (const link of value.threads) {
+        const thread = (0, thread_1.lerThread)(root, link.id);
+        for (const session of thread.sessoes) {
+            const result = stop(session.sessionId);
+            value.stopStack.push({ thread: link.id, session: session.sessionId, stopped: result.codigo === 0, detail: result.texto });
+        }
+    }
+    value.status = 'stopped';
+    value.pauseReason = 'stop.requested';
+    return persist(root, value);
+}
+/** Compensação não para runtimes: só cancela o ticket desta intenção antes da execução. */
+function compensateReservedObjective(root, operationId, principal) {
+    return (0, creation_operation_store_1.withCreationLock)(root, 'objectives', () => {
+        const op = (0, creation_operation_store_1.readCreationOperation)(root, operationId, principal);
+        const id = op.reserved.ticketId;
+        if (!id || !fs.existsSync(objectiveFile(root, id)))
+            return null;
+        const value = readObjective(root, id);
+        if (value.creationOrigin?.operationId !== operationId || value.creationOrigin?.requestHash !== op.requestHash
+            || value.creationOrigin?.ticketId !== id || JSON.stringify(value.threads.map((t) => t.id)) !== JSON.stringify(op.reserved.threadIds)) {
+            throw new Error('creation.conflict: ticket não pertence à operação');
+        }
+        if (value.status === 'stopped' && value.pauseReason === 'creation.compensated')
+            return value;
+        if (value.approval || value.status !== 'awaiting_approval' || value.revisions || value.validations.length) {
+            throw new Error('creation.started: ticket aprovado ou alterado; ação operacional necessária');
+        }
+        const ids = value.threads.map((t) => t.id).filter((threadId) => fs.existsSync((0, thread_1.caminhoThread)(root, threadId))).sort();
+        const lock = (index) => index < ids.length ? (0, hitl_gates_1.comLockHitl)(root, ids[index], () => lock(index + 1)) : cancel();
+        const cancel = () => {
+            for (const threadId of ids) {
+                const thread = (0, thread_1.lerThread)(root, threadId);
+                if (thread.creationOrigin?.operationId !== operationId || thread.creationOrigin?.requestHash !== op.requestHash
+                    || thread.sessoes.length || thread.decisoes.length || thread.faseAtual !== thread.fases[0] || thread.status !== 'aberta') {
+                    throw new Error('creation.started: thread alheia, alterada ou despachada');
+                }
+            }
+            value.status = 'stopped';
+            value.pauseReason = 'creation.compensated';
+            persist(root, value);
+            return readObjective(root, id);
+        };
+        return lock(0);
+    });
+}
+function objectivePhases(root, value) {
+    const threads = value.threads.map((item) => (0, thread_1.lerThread)(root, item.id));
+    return types_1.FASES.map((phase, index) => {
+        if (value.status === 'awaiting_approval' || value.status === 'paused')
+            return { phase, state: 'waiting' };
+        const positions = threads.map((thread) => thread.status === 'fechada' ? types_1.FASES.length : types_1.FASES.indexOf(thread.faseAtual));
+        return { phase, state: positions.every((position) => position > index) ? 'done' : positions.some((position) => position === index) ? 'active' : 'waiting' };
+    });
+}
+function objectiveText(root, value) {
+    const rows = value.threads.map((item) => { const thread = (0, thread_1.lerThread)(root, item.id); return [item.role, item.id, thread.faseAtual, thread.status]; });
+    return [`Objective ${value.id}: ${value.title}`, `Estado: ${value.status}; envelope ${value.envelope.hash.slice(0, 12)}; pausa: ${value.pauseReason ?? 'nenhuma'}`,
+        `Execução: ${value.envelope.executionRuntime}; ensemble: ${value.envelope.validationRuntimes.join(', ')}`, (0, util_1.tabela)(['PAPEL', 'THREAD', 'FASE', 'ESTADO'], rows)].join('\n');
+}