oxe-cc 1.4.0 → 1.5.0

package/docs/WALKTHROUGH.md

@@ -0,0 +1,241 @@
+# OXE — Walkthrough Reproduzível
+
+> Feature: "Adicionar endpoint REST `GET /api/items` de listagem paginada"
+>
+> Tempo estimado: 20 minutos. Todos os comandos são reproduzíveis — copie e execute.
+
+---
+
+## Pré-requisitos
+
+```bash
+npx oxe-cc doctor
+# ✓ Node 18+
+# ✓ Workflows presentes
+# ✓ Estrutura base .oxe/
+```
+
+Se algum item falhar, siga o conselho exibido antes de continuar.
+
+---
+
+## Passo 1 — Descobrir onde você está
+
+```
+/oxe
+```
+
+**Output esperado (projeto novo):**
+```
+Estado atual: init
+Próximo passo recomendado: /oxe-scan
+Motivo: nenhum mapeamento de codebase encontrado em .oxe/codebase/
+```
+
+**Artefato gerado:** nenhum (apenas diagnóstico)
+
+---
+
+## Passo 2 — Mapear o codebase
+
+```
+/oxe-scan
+```
+
+**Output esperado:**
+```
+Scan completo.
+Arquivos mapeados: 47
+Módulos detectados: routes/, controllers/, services/, tests/
+Artefato: .oxe/codebase/map.json
+```
+
+**Artefato gerado:** `.oxe/codebase/map.json`
+
+---
+
+## Passo 3 — Gerar critérios de aceite
+
+```
+/oxe-spec
+
+> Adicionar endpoint GET /api/items com paginação (page, limit). Retornar lista de items e metadados de paginação.
+```
+
+**Output esperado:**
+```
+SPEC.md gerado.
+Critérios A* (bloqueantes):
+  A1. GET /api/items retorna 200 com lista de items
+  A2. Parâmetros page e limit são aceitos e validados
+  A3. Resposta inclui { items: [...], total, page, limit }
+  A4. Testes de integração cobrem os 3 critérios acima
+
+Critérios B (desejáveis):
+  B1. Cursor inválido retorna 400 com mensagem clara
+  B2. Documentação OpenAPI atualizada
+```
+
+**Artefato gerado:** `.oxe/SPEC.md`
+
+Revise os critérios. Se estiverem corretos, avance.
+
+---
+
+## Passo 4 — Planejar a implementação
+
+```
+/oxe-plan
+```
+
+**Output esperado:**
+```
+PLAN.md gerado.
+Onda 1 (obrigatória):
+  T1. Criar route GET /api/items em routes/items.js
+  T2. Implementar ItemsController.list() com paginação
+  T3. Implementar ItemsService.findPaginated(page, limit)
+  T4. Escrever testes de integração para os 3 critérios A*
+
+Hipótese crítica: ItemsService tem acesso ao repositório de dados correto
+Arquivos-alvo: routes/items.js, controllers/items.js, services/items.js, tests/items.test.js
+```
+
+**Artefato gerado:** `.oxe/PLAN.md`
+
+---
+
+## Passo 5 — Implementar
+
+```
+/oxe-execute
+```
+
+O executor vai implementar T1→T4 em sequência, marcando cada tarefa concluída.
+
+**Output esperado ao final:**
+```
+Onda 1 completa.
+T1 ✓ routes/items.js — route criada
+T2 ✓ controllers/items.js — ItemsController.list() implementado
+T3 ✓ services/items.js — ItemsService.findPaginated() implementado
+T4 ✓ tests/items.test.js — 4 testes de integração passando
+
+Estado: execute_complete
+```
+
+**Para executar uma tarefa específica:**
+```
+/oxe-execute --task T3
+```
+
+---
+
+## Passo 6 — Verificar
+
+```
+/oxe-verify
+```
+
+**Output esperado:**
+```
+Verificação completa.
+
+A1 ✓ GET /api/items retorna 200 — evidência: tests/items.test.js:12
+A2 ✓ Parâmetros page e limit validados — evidência: controllers/items.js:34
+A3 ✓ Resposta inclui {items, total, page, limit} — evidência: controllers/items.js:41
+A4 ✓ Testes cobrem A1–A3 — evidência: tests/items.test.js (4 testes)
+
+Riscos residuais: nenhum
+Estado: verify_complete
+```
+
+**Artefato gerado:** `.oxe/VERIFY.md`
+
+---
+
+## Passo 7 — Gate de aprovação (opcional, runtime-first)
+
+Se o projeto usa runtime gates:
+
+```bash
+npx oxe-cc runtime gates list --dir .
+```
+
+**Output esperado:**
+```
+Gates pendentes: 1
+  ⏳ gate-001  tipo: verify_complete  estado: pending
+               ação sugerida: approve
+               impacto: bloqueia promoção para pr_draft
+```
+
+Para aprovar:
+```bash
+npx oxe-cc runtime gates resolve --dir . --gate gate-001 --decision approve --actor "seu-nome"
+```
+
+**Output esperado:**
+```
+✓ Gate gate-001 aprovado.
+Run pode avançar para promoção — nenhum gate restante.
+```
+
+---
+
+## Passo 8 — Promover para PR draft
+
+```bash
+npx oxe-cc runtime promote --dir . --target pr_draft
+```
+
+**Output esperado:**
+```
+Promoção para pr_draft iniciada.
+Branch: feature/items-endpoint
+VERIFY.md incluído como evidência
+PR draft criado: https://github.com/seu-org/repo/pull/42
+```
+
+---
+
+## Estado final dos artefatos
+
+```
+.oxe/
+├── STATE.md          # fase: verify_complete (ou pr_draft após promote)
+├── SPEC.md           # critérios A1–A4 + B1–B2
+├── PLAN.md           # ondas e tarefas T1–T4
+├── VERIFY.md         # evidências para cada critério A*
+└── codebase/
+    └── map.json      # mapa do projeto
+```
+
+---
+
+## Validação rápida
+
+```bash
+npx oxe-cc status
+```
+
+**Output esperado:**
+```
+Estado: verify_complete
+Próximo passo: runtime promote --target pr_draft (ou abrir PR manualmente)
+SPEC: 4 critérios A* — todos verificados
+VERIFY.md: presente
+Gates pendentes: 0
+```
+
+---
+
+## Se algo der errado
+
+| Sintoma | Comando |
+|---------|---------|
+| Travado em uma tarefa | `/oxe-debug` |
+| Critério A* não verificado | `/oxe-verify` + revisar implementação |
+| Gate stale (>24h) | Ver [`docs/INCIDENT-PLAYBOOK.md`](INCIDENT-PLAYBOOK.md) |
+| Plano desatualizado | `/oxe-plan` novamente (sobrescreve PLAN.md) |
+| Estado incoerente | `npx oxe-cc status --full` + `/oxe` para rediagnóstico |

package/lib/runtime/scheduler/multi-agent-coordinator.d.ts

@@ -17,6 +17,7 @@ export interface CoordinationOptions {
     sessionId: string | null;
     runId: string;
     onEvent?: SchedulerContext['onEvent'];
+    heartbeatTimeoutMs?: number;
 }
 export interface ArbitrationRecord {
     work_item_id: string;
@@ -48,12 +49,36 @@ export interface MultiAgentStatusSnapshot {
         assigned_task_ids: string[];
         completed: string[];
         failed: string[];
+        timed_out: boolean;
+        reassigned_task_ids: string[];
     }>;
     orphan_reassignments: Array<{
         from_agent_id: string;
         to_agent_id: string;
         work_item_ids: string[];
     }>;
+    timed_out_agents: Array<{
+        agent_id: string;
+        work_item_ids: string[];
+        detected_at: string;
+    }>;
+    updated_at: string;
+}
+export interface MultiAgentOperationalSummary {
+    run_id: string;
+    mode: CoordinationMode;
+    workspace_isolation_enforced: boolean;
+    agent_count: number;
+    completed_count: number;
+    failed_count: number;
+    blocked_count: number;
+    ownership_count: number;
+    handoff_count: number;
+    arbitration_count: number;
+    orphan_reassignment_count: number;
+    timeout_count: number;
+    participating_agents: string[];
+    health: 'healthy' | 'degraded';
     updated_at: string;
 }
 export interface CoordinationResult {
@@ -70,9 +95,12 @@ export interface CoordinationResult {
     handoffs?: CooperativeHandoff[];
     arbitration_results?: ArbitrationRecord[];
     state?: MultiAgentStatusSnapshot;
+    summary?: MultiAgentOperationalSummary;
 }
 export declare class MultiAgentCoordinator {
     run(graph: ExecutionGraph, opts: CoordinationOptions): Promise<CoordinationResult>;
 }
 export declare function multiAgentStatePath(projectRoot: string, runId: string): string;
+export declare function multiAgentSummaryPath(projectRoot: string, runId: string): string;
 export declare function loadMultiAgentState(projectRoot: string, runId: string): MultiAgentStatusSnapshot | null;
+export declare function loadMultiAgentSummary(projectRoot: string, runId: string): MultiAgentOperationalSummary | null;

package/lib/runtime/scheduler/multi-agent-coordinator.js

@@ -5,12 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiAgentCoordinator = void 0;
 exports.multiAgentStatePath = multiAgentStatePath;
+exports.multiAgentSummaryPath = multiAgentSummaryPath;
 exports.loadMultiAgentState = loadMultiAgentState;
+exports.loadMultiAgentSummary = loadMultiAgentSummary;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const bus_1 = require("../events/bus");
 const scheduler_1 = require("./scheduler");
 const agent_roles_1 = require("./agent-roles");
+const agent_registry_1 = require("./agent-registry");
 function ensureRunDir(projectRoot, runId) {
     const dir = path_1.default.join(projectRoot, '.oxe', 'runs', runId);
     fs_1.default.mkdirSync(dir, { recursive: true });
@@ -21,6 +24,24 @@ function persistMultiAgentArtifacts(projectRoot, runId, state, handoffs = [], ar
     fs_1.default.writeFileSync(path_1.default.join(runDir, 'multi-agent-state.json'), JSON.stringify(state, null, 2), 'utf8');
     fs_1.default.writeFileSync(path_1.default.join(runDir, 'handoffs.json'), JSON.stringify(handoffs, null, 2), 'utf8');
     fs_1.default.writeFileSync(path_1.default.join(runDir, 'arbitration-results.json'), JSON.stringify(arbitrationResults, null, 2), 'utf8');
+    const summary = {
+        run_id: state.run_id,
+        mode: state.mode,
+        workspace_isolation_enforced: state.workspace_isolation_enforced,
+        agent_count: state.agent_count,
+        completed_count: state.completed.length,
+        failed_count: state.failed.length,
+        blocked_count: state.blocked.length,
+        ownership_count: state.ownership.length,
+        handoff_count: handoffs.length,
+        arbitration_count: arbitrationResults.length,
+        orphan_reassignment_count: state.orphan_reassignments.length,
+        timeout_count: state.timed_out_agents.length,
+        participating_agents: state.agent_results.map((entry) => entry.agent_id),
+        health: state.timed_out_agents.length > 0 || state.failed.length > 0 ? 'degraded' : 'healthy',
+        updated_at: state.updated_at,
+    };
+    fs_1.default.writeFileSync(path_1.default.join(runDir, 'multi-agent-summary.json'), JSON.stringify(summary, null, 2), 'utf8');
 }
 function ensureIsolatedAgents(agents) {
     const shared = agents.filter((agent) => agent.workspaceManager.isolation_level !== 'isolated');
@@ -41,7 +62,7 @@ function buildOwnership(agents, partitions) {
     }
     return ownership;
 }
-function makeState(mode, runId, agents, partitions, agentResults, completed, failed, blocked, orphanReassignments) {
+function makeState(mode, runId, agents, partitions, agentResults, completed, failed, blocked, orphanReassignments, timedOutAgents) {
     return {
         run_id: runId,
         mode,
@@ -60,16 +81,82 @@ function makeState(mode, runId, agents, partitions, agentResults, completed, fai
                 assigned_task_ids: partitions[idx] ?? agent.assignedTaskIds ?? [],
                 completed: result?.completed ?? [],
                 failed: result?.failed ?? [],
+                timed_out: Boolean(result?.timed_out),
+                reassigned_task_ids: result?.reassigned_task_ids ?? [],
             };
         }),
         orphan_reassignments: orphanReassignments,
+        timed_out_agents: timedOutAgents,
         updated_at: new Date().toISOString(),
     };
 }
+async function runGraphForAgent(graph, nodeIds, agent, idx, opts, heartbeatTimeoutMs) {
+    const subGraph = subGraphFor(graph, nodeIds);
+    if (subGraph.nodes.size === 0) {
+        return {
+            agent_id: agent.id,
+            completed: [],
+            failed: [],
+            timed_out: false,
+            assigned_task_ids: nodeIds,
+            reassigned_task_ids: [],
+        };
+    }
+    const ctx = {
+        projectRoot: opts.projectRoot,
+        sessionId: opts.sessionId,
+        runId: `${opts.runId}-agent${idx}`,
+        executor: agent.executor,
+        workspaceManager: agent.workspaceManager,
+        onEvent: opts.onEvent,
+    };
+    const scheduler = new scheduler_1.Scheduler();
+    const work = scheduler.run(subGraph, ctx);
+    if (!heartbeatTimeoutMs || heartbeatTimeoutMs <= 0) {
+        const result = await work;
+        return {
+            agent_id: agent.id,
+            completed: result.completed,
+            failed: result.failed,
+            timed_out: false,
+            assigned_task_ids: nodeIds,
+            reassigned_task_ids: [],
+        };
+    }
+    let timer = null;
+    const raced = await Promise.race([
+        work.then((result) => ({ type: 'result', result })),
+        new Promise((resolve) => {
+            timer = setTimeout(() => resolve({ type: 'timeout' }), heartbeatTimeoutMs);
+        }),
+    ]);
+    if (timer)
+        clearTimeout(timer);
+    if (raced && raced.type === 'timeout') {
+        return {
+            agent_id: agent.id,
+            completed: [],
+            failed: [],
+            timed_out: true,
+            assigned_task_ids: nodeIds,
+            reassigned_task_ids: [],
+        };
+    }
+    const result = raced.result;
+    return {
+        agent_id: agent.id,
+        completed: result.completed,
+        failed: result.failed,
+        timed_out: false,
+        assigned_task_ids: nodeIds,
+        reassigned_task_ids: [],
+    };
+}
 // ─── Parallel mode ───────────────────────────────────────────────────────────
 async function runParallel(graph, opts) {
     const { agents, projectRoot, sessionId, runId } = opts;
     ensureIsolatedAgents(agents);
+    const heartbeatTimeoutMs = opts.heartbeatTimeoutMs ?? null;
     const partitions = agents.map((agent) => [...(agent.assignedTaskIds ?? [])]);
     if (partitions.every((partition) => partition.length === 0)) {
         const allIds = [...graph.nodes.keys()];
@@ -77,33 +164,55 @@ async function runParallel(graph, opts) {
             partitions[index % agents.length].push(id);
         });
     }
+    const registry = new agent_registry_1.AgentRegistry(heartbeatTimeoutMs == null ? 30000 : heartbeatTimeoutMs);
+    agents.forEach((agent, idx) => {
+        registry.register(agent.id, agent.executor, agent.workspaceManager, partitions[idx] ?? []);
+    });
     (0, bus_1.appendEvent)(projectRoot, sessionId, {
         type: 'RunStarted',
         run_id: runId,
         payload: { mode: 'parallel', agent_count: agents.length, isolation_level: 'isolated' },
     });
-    const agentResults = await Promise.all(agents.map(async (agent, idx) => {
-        const subGraph = subGraphFor(graph, partitions[idx]);
-        if (subGraph.nodes.size === 0) {
-            return { agent_id: agent.id, completed: [], failed: [] };
-        }
-        const ctx = {
-            projectRoot,
-            sessionId,
-            runId: `${runId}-agent${idx}`,
-            executor: agent.executor,
-            workspaceManager: agent.workspaceManager,
-            onEvent: opts.onEvent,
-        };
-        const scheduler = new scheduler_1.Scheduler();
-        const result = await scheduler.run(subGraph, ctx);
-        return { agent_id: agent.id, completed: result.completed, failed: result.failed };
+    const initialResults = await Promise.all(agents.map(async (agent, idx) => {
+        registry.beat(agent.id, partitions[idx][0] || null);
+        const result = await runGraphForAgent(graph, partitions[idx], agent, idx, opts, heartbeatTimeoutMs);
+        registry.setStatus(agent.id, result.timed_out ? 'timeout' : 'idle');
+        return result;
     }));
-    const completed = agentResults.flatMap((result) => result.completed);
-    const failed = agentResults.flatMap((result) => result.failed);
+    const timedOutAgents = [];
     const blocked = [];
     const orphanReassignments = [];
-    const state = makeState('parallel', runId, agents, partitions, agentResults, completed, failed, blocked, orphanReassignments);
+    const agentResults = initialResults.map((entry) => ({
+        ...entry,
+        reassigned_task_ids: entry.reassigned_task_ids || [],
+    }));
+    const liveAgents = agentResults.filter((entry) => !entry.timed_out);
+    for (const timedOut of agentResults.filter((entry) => entry.timed_out)) {
+        timedOutAgents.push({
+            agent_id: timedOut.agent_id,
+            work_item_ids: timedOut.assigned_task_ids,
+            detected_at: new Date().toISOString(),
+        });
+        const fallback = liveAgents.find((entry) => entry.agent_id !== timedOut.agent_id);
+        if (!fallback || timedOut.assigned_task_ids.length === 0)
+            continue;
+        const fallbackIdx = agents.findIndex((agent) => agent.id === fallback.agent_id);
+        const timeoutIdx = agents.findIndex((agent) => agent.id === timedOut.agent_id);
+        const rerun = await runGraphForAgent(graph, timedOut.assigned_task_ids, agents[fallbackIdx], fallbackIdx, opts, null);
+        fallback.completed.push(...rerun.completed);
+        fallback.failed.push(...rerun.failed);
+        fallback.reassigned_task_ids.push(...timedOut.assigned_task_ids);
+        partitions[fallbackIdx] = [...partitions[fallbackIdx], ...timedOut.assigned_task_ids];
+        partitions[timeoutIdx] = [];
+        orphanReassignments.push({
+            from_agent_id: timedOut.agent_id,
+            to_agent_id: fallback.agent_id,
+            work_item_ids: timedOut.assigned_task_ids,
+        });
+    }
+    const completed = Array.from(new Set(agentResults.flatMap((result) => result.completed)));
+    const failed = Array.from(new Set(agentResults.flatMap((result) => result.failed)));
+    const state = makeState('parallel', runId, agents, partitions, agentResults, completed, failed, blocked, orphanReassignments, timedOutAgents);
     persistMultiAgentArtifacts(projectRoot, runId, state);
     (0, bus_1.appendEvent)(projectRoot, sessionId, {
         type: 'RunCompleted',
@@ -119,6 +228,7 @@ async function runParallel(graph, opts) {
         agent_results: agentResults,
         arbitration_results: [],
         state,
+        summary: loadMultiAgentSummary(projectRoot, runId) || undefined,
     };
 }
 // ─── Competitive mode ────────────────────────────────────────────────────────
@@ -154,9 +264,9 @@ async function runCompetitive(graph, opts) {
     }
     const partitions = [Array.from(graph.nodes.keys()), Array.from(graph.nodes.keys())];
     const state = makeState('competitive', runId, opts.agents, partitions, [
-        { agent_id: agentA.id, completed, failed },
-        { agent_id: agentB.id, completed: [], failed: [] },
-    ], completed, failed, blocked, []);
+        { agent_id: agentA.id, completed, failed, timed_out: false, reassigned_task_ids: [] },
+        { agent_id: agentB.id, completed: [], failed: [], timed_out: false, reassigned_task_ids: [] },
+    ], completed, failed, blocked, [], []);
     persistMultiAgentArtifacts(projectRoot, runId, state, [], arbitrationResults);
     (0, bus_1.appendEvent)(projectRoot, sessionId, {
         type: 'RunCompleted',
@@ -175,6 +285,7 @@ async function runCompetitive(graph, opts) {
         ],
         arbitration_results: arbitrationResults,
         state,
+        summary: loadMultiAgentSummary(projectRoot, runId) || undefined,
     };
 }
 async function competeTwoAgents(nodeId, node, agentA, agentB, opts, arbitrationResults) {
@@ -294,9 +405,9 @@ async function runCooperative(graph, opts) {
     }
     const partitions = [Array.from(graph.nodes.keys()), Array.from(graph.nodes.keys())];
     const state = makeState('cooperative', runId, opts.agents, partitions, [
-        { agent_id: planner.id, completed: [], failed: [] },
-        { agent_id: executor.id, completed, failed },
-    ], completed, failed, blocked, []);
+        { agent_id: planner.id, completed: [], failed: [], timed_out: false, reassigned_task_ids: [] },
+        { agent_id: executor.id, completed, failed, timed_out: false, reassigned_task_ids: [] },
+    ], completed, failed, blocked, [], []);
     persistMultiAgentArtifacts(projectRoot, runId, state, handoffs, []);
     (0, bus_1.appendEvent)(projectRoot, sessionId, {
         type: 'RunCompleted',
@@ -316,6 +427,7 @@ async function runCooperative(graph, opts) {
         handoffs,
         arbitration_results: [],
         state,
+        summary: loadMultiAgentSummary(projectRoot, runId) || undefined,
     };
 }
 // ─── Public API ──────────────────────────────────────────────────────────────
@@ -334,6 +446,9 @@ exports.MultiAgentCoordinator = MultiAgentCoordinator;
 function multiAgentStatePath(projectRoot, runId) {
     return path_1.default.join(projectRoot, '.oxe', 'runs', runId, 'multi-agent-state.json');
 }
+function multiAgentSummaryPath(projectRoot, runId) {
+    return path_1.default.join(projectRoot, '.oxe', 'runs', runId, 'multi-agent-summary.json');
+}
 function loadMultiAgentState(projectRoot, runId) {
     const statePath = multiAgentStatePath(projectRoot, runId);
     if (!fs_1.default.existsSync(statePath))
@@ -345,6 +460,17 @@ function loadMultiAgentState(projectRoot, runId) {
         return null;
     }
 }
+function loadMultiAgentSummary(projectRoot, runId) {
+    const summaryPath = multiAgentSummaryPath(projectRoot, runId);
+    if (!fs_1.default.existsSync(summaryPath))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(summaryPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function subGraphFor(graph, nodeIds) {
     const ids = new Set(nodeIds);

package/lib/sdk/README.md

@@ -76,5 +76,7 @@ O SDK já expõe os helpers usados pela operação enterprise do OXE:
 - `operational.readRuntimeGates(...)` / `operational.resolveRuntimeGate(...)`
 - `operational.recoverRuntimeState(...)` / `operational.replayRuntimeState(...)`
 - `operational.readRuntimeMultiAgentStatus(...)` / `operational.multiAgentStatus(...)`
+- `release.checkReleaseConsistency(...)` / `release.buildReleaseManifest(...)`
+- `release.loadRuntimeSmokeReport(...)` / `release.loadRecoveryFixtureReport(...)` / `release.loadMultiAgentSoakReport(...)`
 
 Use esses helpers quando quiser integrar gates, verify, recovery e multi-agent a scripts de CI, automações internas ou observabilidade.

package/lib/sdk/index.cjs

@@ -17,8 +17,9 @@ const plugins = require('../../bin/lib/oxe-plugins.cjs');
 const dashboard = require('../../bin/lib/oxe-dashboard.cjs');
 const operational = require('../../bin/lib/oxe-operational.cjs');
 const azure = require('../../bin/lib/oxe-azure.cjs');
-const context = require('../../bin/lib/oxe-context-engine.cjs');
-const runtimeSemantics = require('../../bin/lib/oxe-runtime-semantics.cjs');
+const context = require('../../bin/lib/oxe-context-engine.cjs');
+const runtimeSemantics = require('../../bin/lib/oxe-runtime-semantics.cjs');
+const release = require('../../bin/lib/oxe-release.cjs');
 
 const PACKAGE_ROOT = path.join(__dirname, '..', '..');
 
@@ -636,12 +637,25 @@ module.exports = {
   },
 
   /** Dashboard local: contexto consolidado e persistência de revisão do plano. */
-  dashboard: {
-    loadDashboardContext: dashboard.loadDashboardContext,
-    savePlanReviewStatus: dashboard.savePlanReviewStatus,
-    addPlanReviewComment: dashboard.addPlanReviewComment,
-    updatePlanReviewCommentStatus: dashboard.updatePlanReviewCommentStatus,
-  },
+  dashboard: {
+    loadDashboardContext: dashboard.loadDashboardContext,
+    savePlanReviewStatus: dashboard.savePlanReviewStatus,
+    addPlanReviewComment: dashboard.addPlanReviewComment,
+    updatePlanReviewCommentStatus: dashboard.updatePlanReviewCommentStatus,
+  },
+
+  /** Release readiness: manifest, smoke matrix e checks de consistência antes de publicar. */
+  release: {
+    REQUIRED_RUNTIMES: release.REQUIRED_RUNTIMES,
+    WRAPPER_TARGETS: release.WRAPPER_TARGETS,
+    releasePaths: release.releasePaths,
+    collectWrapperHashes: release.collectWrapperHashes,
+    loadRuntimeSmokeReport: release.loadRuntimeSmokeReport,
+    loadRecoveryFixtureReport: release.loadRecoveryFixtureReport,
+    loadMultiAgentSoakReport: release.loadMultiAgentSoakReport,
+    buildReleaseManifest: release.buildReleaseManifest,
+    checkReleaseConsistency: release.checkReleaseConsistency,
+  },
 
   /** Runtime operacional: tracing, active run, catálogo de capabilities e memória em camadas. */
   operational: {