oxe-cc 1.4.1 → 1.5.0

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: {

package/lib/sdk/index.d.ts

@@ -146,18 +146,50 @@ export interface GateQueueSnapshot {
   all?: Array<Record<string, unknown>>;
 }
 
-export interface MultiAgentStatusSummary {
-  path: string | null;
-  enabled: boolean;
-  runId: string | null;
-  mode: string | null;
+export interface MultiAgentStatusSummary {
+  path: string | null;
+  enabled: boolean;
+  runId: string | null;
+  mode: string | null;
   workspaceIsolationEnforced: boolean;
   agents: Array<Record<string, unknown>>;
-  ownership: Array<Record<string, unknown>>;
-  orphanReassignments: Array<Record<string, unknown>>;
-  handoffs: Array<Record<string, unknown>>;
-  arbitrationResults: Array<Record<string, unknown>>;
-}
+  ownership: Array<Record<string, unknown>>;
+  orphanReassignments: Array<Record<string, unknown>>;
+  handoffs: Array<Record<string, unknown>>;
+  arbitrationResults: Array<Record<string, unknown>>;
+  summary?: Record<string, unknown> | null;
+}
+
+export interface ReleaseManifest {
+  schema_version: number;
+  generated_at: string;
+  project_root: string;
+  package_root: string;
+  release_contract: Record<string, unknown>;
+  versions: Record<string, unknown>;
+  runtime_compiled: { path: string; ok: boolean };
+  wrappers: Record<string, unknown>;
+  reports: Record<string, unknown>;
+}
+
+export interface ReleaseConsistencyResult {
+  ok: boolean;
+  blockers: string[];
+  warnings: string[];
+  manifest: ReleaseManifest;
+  manifestPath: string;
+}
+
+export interface RuntimeSmokeReport {
+  path: string;
+  present: boolean;
+  ok: boolean;
+  total: number;
+  failures: string[];
+  missingRequired: string[];
+  results: Array<Record<string, unknown>>;
+  raw: Record<string, unknown> | null;
+}
 
 export interface PolicyDecisionSummary {
   total: number;
@@ -685,12 +717,24 @@ export interface OxeSdk {
     installNpmPlugin: (projectRoot: string, pkgName: string, version?: string) => { ok: boolean; path: string; error: string };
   };
 
-  dashboard: {
-    loadDashboardContext: (projectRoot: string, opts?: { activeSession?: string | null }) => Record<string, unknown>;
-    savePlanReviewStatus: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown>;
-    addPlanReviewComment: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown>;
-    updatePlanReviewCommentStatus: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown> | null;
-  };
+  dashboard: {
+    loadDashboardContext: (projectRoot: string, opts?: { activeSession?: string | null }) => Record<string, unknown>;
+    savePlanReviewStatus: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown>;
+    addPlanReviewComment: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown>;
+    updatePlanReviewCommentStatus: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown> | null;
+  };
+
+  release: {
+    REQUIRED_RUNTIMES: string[];
+    WRAPPER_TARGETS: Array<Record<string, unknown>>;
+    releasePaths: (projectRoot: string) => Record<string, string>;
+    collectWrapperHashes: (projectRoot: string) => Record<string, unknown>;
+    loadRuntimeSmokeReport: (projectRoot: string) => RuntimeSmokeReport;
+    loadRecoveryFixtureReport: (projectRoot: string) => RuntimeSmokeReport;
+    loadMultiAgentSoakReport: (projectRoot: string) => RuntimeSmokeReport;
+    buildReleaseManifest: (projectRoot: string, options?: Record<string, unknown>) => ReleaseManifest;
+    checkReleaseConsistency: (projectRoot: string, options?: Record<string, unknown>) => ReleaseConsistencyResult;
+  };
 
   context: ContextAPI;
   runtimeSemantics: RuntimeSemanticsAPI;

package/oxe/templates/config.template.json

@@ -30,6 +30,7 @@
   "install": {
     "profile": "recommended",
     "repo_layout": "nested",
+    "ide_scope": "global",
     "vscode": false,
     "include_commands_dir": true,
     "include_agents_md": true

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "oxe-cc",
-	"version": "1.4.1",
+	"version": "1.5.0",
 	"description": "OXE — spec-driven workflows in .oxe/ with runtime enterprise, evidence-first verification and multi-runtime integrations (npx)",
 	"license": "MIT",
 	"author": "",
@@ -38,7 +38,8 @@
 	},
 	"types": "lib/sdk/index.d.ts",
 	"bin": {
-		"oxe-cc": "bin/oxe-cc.js"
+		"oxe-cc": "bin/oxe-cc.js",
+		"oxe": "bin/oxe-cc.js"
 	},
 	"files": [
 		"bin",
@@ -46,28 +47,35 @@
 		"oxe",
 		"assets",
 		".cursor",
-		".github",
-		"commands",
-		"vscode-extension",
-		"packages/runtime/src",
-		"packages/runtime/package.json",
-		"packages/runtime/tsconfig.json",
+		".github",
+		"commands",
+		"vscode-extension",
+		"docs",
+		"QUICKSTART.md",
+		"packages/runtime/src",
+		"packages/runtime/package.json",
+		"packages/runtime/tsconfig.json",
 		"AGENTS.md",
 		"README.md",
 		"CHANGELOG.md"
 	],
-	"scripts": {
-		"build:runtime": "cd packages/runtime && npm run build",
-		"sync:runtime-metadata": "node scripts/sync-runtime-metadata.cjs",
-		"sync:cursor": "node scripts/sync-cursor-from-prompts.cjs",
-		"test:root": "node --test tests/install.test.cjs tests/oxe-project-health.test.cjs tests/oxe-dashboard.test.cjs tests/oxe-operational.test.cjs tests/oxe-azure.test.cjs tests/oxe-sdk.test.cjs tests/oxe-manifest.test.cjs tests/oxe-agent-install.test.cjs tests/oxe-install-resolve-full.test.cjs tests/oxe-health-extended.test.cjs tests/oxe-workflows-edge.test.cjs tests/oxe-sdk-edge.test.cjs tests/oxe-cli-edge.test.cjs tests/oxe-npm-version.test.cjs tests/oxe-scripts.test.cjs tests/oxe-retro-health.test.cjs tests/oxe-security-permissions.test.cjs tests/oxe-runtime-semantics.test.cjs tests/oxe-plugins.test.cjs",
-		"test:runtime": "cd packages/runtime && npm test",
-		"test": "npm run build:runtime && npm run test:root && npm run test:runtime",
-		"test:coverage": "c8 --check-coverage --lines 82 --functions 85 --branches 58 --statements 82 npm test",
-		"scan:assets": "node scripts/oxe-assets-scan.cjs",
-		"build:vscode-ext": "cd vscode-extension && npx @vscode/vsce package --no-yarn --allow-missing-repository",
-		"prepublishOnly": "npm run build:vscode-ext && node scripts/sync-runtime-metadata.cjs && node scripts/sync-cursor-from-prompts.cjs && npm test && npm run scan:assets && node bin/oxe-cc.js --version"
-	},
+	"scripts": {
+		"build:runtime": "cd packages/runtime && npm run build",
+		"sync:runtime-metadata": "node scripts/sync-runtime-metadata.cjs",
+		"sync:cursor": "node scripts/sync-cursor-from-prompts.cjs",
+		"release:doctor": "node scripts/release-doctor.cjs",
+		"release:manifest": "node scripts/release-doctor.cjs --write-manifest",
+		"test:root": "node --test tests/install.test.cjs tests/oxe-project-health.test.cjs tests/oxe-dashboard.test.cjs tests/oxe-operational.test.cjs tests/oxe-azure.test.cjs tests/oxe-sdk.test.cjs tests/oxe-manifest.test.cjs tests/oxe-agent-install.test.cjs tests/oxe-install-resolve-full.test.cjs tests/oxe-health-extended.test.cjs tests/oxe-workflows-edge.test.cjs tests/oxe-sdk-edge.test.cjs tests/oxe-cli-edge.test.cjs tests/oxe-npm-version.test.cjs tests/oxe-scripts.test.cjs tests/oxe-retro-health.test.cjs tests/oxe-security-permissions.test.cjs tests/oxe-runtime-semantics.test.cjs tests/oxe-plugins.test.cjs",
+		"test:runtime": "cd packages/runtime && npm test",
+		"test:runtime-smoke": "node scripts/runtime-smoke-matrix.cjs",
+		"test:recovery-fixtures": "node scripts/run-recovery-fixtures.cjs",
+		"test:multi-agent-soak": "node scripts/run-multi-agent-soak.cjs",
+		"test": "npm run build:runtime && npm run test:root && npm run test:runtime && npm run test:runtime-smoke && npm run test:recovery-fixtures && npm run test:multi-agent-soak",
+		"test:coverage": "c8 --check-coverage --lines 82 --functions 85 --branches 58 --statements 82 npm test",
+		"scan:assets": "node scripts/oxe-assets-scan.cjs",
+		"build:vscode-ext": "cd vscode-extension && npx @vscode/vsce package --no-yarn --allow-missing-repository",
+		"prepublishOnly": "npm test && npm run scan:assets && npm run build:vscode-ext && npm run release:manifest && node bin/oxe-cc.js --version"
+	},
 	"c8": {
 		"all": true,
 		"include": [

package/packages/runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxe/runtime",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "private": true,
   "license": "MIT",
   "description": "OXE agentic execution engine — enterprise runtime core",