@cocreate/server-autoscaler 1.0.1 → 1.0.3

package/src/index.js

@@ -17,415 +17,377 @@
  ********************************************************************************/
 
 import cluster from 'node:cluster';
-import https from 'node:https';
-import os from 'node:os';
 import Config from '@cocreate/config';
 import { getValueFromObject } from '@cocreate/utils';
+import { getCloudProvider } from './geoScaling.js';
 
 // Guard clause verification to ensure cluster API abstraction integrity
-const isPrimary = cluster.isPrimary !== undefined ? cluster.isPrimary : cluster.isMaster;
+const isMaster = cluster.isMaster;
 
-// ==============================================================================
-// Module-Level Sandbox State (ESM Singleton Container)
-// ==============================================================================
-let serverCtx = null;             // Central reference to CoCreateServer Primary instance
+let server = null;                // Central reference to CoCreateServer Master instance
 let autoscaleConfig = null;       // Configured thresholds and duration constants
 let isRunning = false;            // Execution loop flag
 
-// Consecutive tracking counters to filter transient spikes
+// Consecutive tracking counters to filter transient CPU spikes
 let consecutiveCpuSpikes = 0;
-let consecutiveLowLoadTicks = 0;
+let consecutiveLowLoadFlushes = 0;
 
-// Timestamp tracking to prevent cascading scaling operations (Cooldown Management)
-let lastScaleOperationTimestamp = 0;
-
-// Default operational values for metrics-driven autoscale thresholds
+// Default operational values for telemetry-driven autoscale thresholds
 const defaults = {
-    scaleUpCpuThreshold: 80,             // CPU usage percentage trigger for Scaling Up (Sustained)
-    scaleUpCpuExtremeThreshold: 90,      // Extreme CPU usage trigger for INSTANT Scaling Up (Single Flush)
-    scaleDownCpuThreshold: 25,           // CPU usage percentage trigger for Scaling Down
-    scaleUpMemoryThreshold: 85,          // Heap memory utilization trigger for Scaling Up
-    consecutiveCpuSpikesRequired: 3,     // Require 3 consecutive flushes of high CPU (e.g. 3 minutes)
-    consecutiveLowTicksRequired: 10,     // Require 10 consecutive flushes of low load (e.g. 10 minutes)
-    minClusterSize: 2,                   // Never scale down below this active node count
-    cooldownDurationMs: 300000,          // Cooldown lockout period to stabilize nodes (default: 5 minutes)
-    provisioningApiEndpoint: 'https://api.cocreate.app/v1/infrastructure/scale'
+    // HORIZONTAL THRESHOLDS & SCALE OUT
+    scaleOut: {
+        cpuThreshold: 85,          // % CPU trigger
+        memoryThreshold: 85,       // % Memory trigger
+        consecutiveFlushes: 3,     // Sustained load required
+        maxClusterSize: 0          // Global ceiling (0 = uncapped)
+    },
+
+    // SCALE IN THRESHOLDS & STRATEGY
+    scaleIn: {
+        cpuThreshold: 10,          // % CPU low load trigger
+        memoryThreshold: 45,       // % Memory low load trigger
+        consecutiveFlushes: 10,    // Sustained low load (~10 min window)
+        preservation: "continent", // "global" | "continent" | "country" | "region"
+        minClusterSize: 2,         // Minimum cluster floor
+        decommissionStrategy: "local" // "local" (autonomous self-decommissioning) | "oldest" (target oldest idle node)
+    },
+
+    // GEO-SCALING & EDGE SHEDDING
+    geoScale: {
+        enabled: true,
+        sheddingThreshold: 20,     // % unserved traffic required to spawn edge node
+        densityBy: "continent"     // "continent" | "country" | "region"
+    },
+
+    // REGIONAL VERTICAL TIERING
+    vertical: {
+        enabled: true,
+        maxNodesPerTier: 2,        // Up to 2 horizontal nodes per tier in a region before stepping up to next tier
+        tiers: [
+            { name: "nano",    vCPU: 1,  memoryGb: 2 },
+            { name: "small",   vCPU: 2,  memoryGb: 8 },
+            { name: "medium",  vCPU: 4,  memoryGb: 16 },
+            { name: "large",   vCPU: 8,  memoryGb: 32 },
+            { name: "xlarge",  vCPU: 16, memoryGb: 64 },
+            { name: "2xlarge", vCPU: 32, memoryGb: 128 },
+            { name: "4xlarge", vCPU: 64, memoryGb: 256 }
+        ]
+    }
 };
 
 /**
- * Normalizes dataset arrays returned from standard CRUD database operations.
- */
-function normalizePeersList(result) {
-    if (!result) return [];
-    if (Array.isArray(result)) return result;
-    if (Array.isArray(result.object)) return result.object;
-    if (Array.isArray(result.data)) return result.data;
-    return [];
-}
-
-/**
- * Recursively parses and evaluates an AST rule against a provided context.
+ * Queries the database via CRUD for active servers matching given filter query where master is running.
+ * Accepts optional query parameters to target specific geographic zones or regions.
  * 
- * @param {Object} node - AST node definition
- * @param {Object} context - Combined telemetry metrics and state counters
- * @returns {boolean} Outcome of the evaluation statement
+ * @param {Object} [query={}] - Optional query filters to merge with default master status
+ * @returns {Object|null} Cluster snapshot including averages and raw active servers array
  */
-function evaluateAST(node, context) {
-    if (!node) return false;
+async function getClusterDetails(query = {}) {
+    try {
+        // Query servers array for active servers where master is running
+        const readResponse = await server.crud.send({
+            method: 'object.read',
+            array: 'servers',
+            $filter: {
+                query: {
+                    'master.status': 'running',
+                    ...query
+                }
+            },
+            organization_id: server.organization_id,
+            host: server.host
+        });
 
-    switch (node.type) {
-        case 'LogicalExpression': {
-            const leftVal = evaluateAST(node.left, context);
-            
-            // Short-circuit evaluations to optimize V8 execution loops
-            if (node.operator === 'OR' && leftVal) return true;
-            if (node.operator === 'AND' && !leftVal) return false;
-
-            const rightVal = evaluateAST(node.right, context);
-            if (node.operator === 'OR') return leftVal || rightVal;
-            if (node.operator === 'AND') return leftVal && rightVal;
-            break;
-        }
+        const activeServers = Array.isArray(readResponse?.object) ? readResponse.object : [];
+        if (activeServers.length === 0) return null;
 
-        case 'Condition': {
-            const metricValue = getValueFromObject(context, node.metric);
-            const targetValue = node.value;
+        let totalCpu = 0;
+        let totalMem = 0;
 
-            if (metricValue === undefined) {
-                console.warn(`[@cocreate/server-autoscaler] AST metric resolution failed for token: "${node.metric}"`);
-                return false;
-            }
-
-            switch (node.operator) {
-                case 'GT': return metricValue > targetValue;
-                case 'GTE': return metricValue >= targetValue;
-                case 'LT': return metricValue < targetValue;
-                case 'LTE': return metricValue <= targetValue;
-                case 'EQ': return metricValue === targetValue;
-                case 'NEQ': return metricValue !== targetValue;
-                default: return false;
-            }
+        for (const serverRecord of activeServers) {
+            const peerTelemetry = serverRecord.telemetry;
+            totalCpu += peerTelemetry?.cpu?.totalUsage || 0;
+            totalMem += peerTelemetry?.memory?.percentage || 0;
         }
 
-        default:
-            console.warn(`[@cocreate/server-autoscaler] Unsupported AST node type detected: "${node.type}"`);
-            return false;
+        const count = activeServers.length;
+
+        return {
+            avgCpu: totalCpu / count,
+            avgMemory: totalMem / count,
+            totalCpu,
+            totalMem,
+            totalCount: count,
+            servers: activeServers // Raw active server array from database
+        };
+    } catch (err) {
+        console.error("[@cocreate/server-autoscaler] Error querying cluster details from DB:", err.message);
+        return null;
     }
-    return false;
 }
 
 /**
- * Invokes an external HTTPS API call modeled around standard CoCreate AST payload shapes.
- * If the Cloud Endpoint is offline or unreachable, falls back to a highly descriptive simulated log.
+ * Validates whether scaling out is necessary by checking Node-level average first,
+ * followed by single-flush Cluster capacity from active server records in the database.
+ * Also enforces maxClusterSize if explicitly configured (> 0).
  * 
- * @param {string} direction - Target scaling direction ('up' | 'down')
- * @param {Object} metrics - Performance statistics triggering the scale event
- * @param {Object} actionConfig - Specific configuration parameters extracted from AST action node
+ * @param {Object} telemetry - Telemetry payload frame
+ * @returns {boolean} True if scaling out is authorized, False if cordoning alone is sufficient or max cap reached
  */
-async function executeScaleAction(direction, metrics, actionConfig = {}) {
-    const targetUrl = getValueFromObject(autoscaleConfig, 'autoscale.apiEndpoint') || defaults.provisioningApiEndpoint;
-    const clusterSecret = process.env.CLUSTER_SECRET || 'LOCAL_SIMULATED_SECRET';
-
-    // Build standard AST-modeled API Payload Object
-    const payload = {
-        method: actionConfig.method || 'infrastructure.scale',
-        timestamp: new Date().toISOString(),
-        serverId: serverCtx?.id || 'simulated-server-id',
-        direction: direction,
-        provider: actionConfig.provider || 'round-robin',
-        spec: actionConfig.spec || 'standard',
-        region: actionConfig.region || 'local',
-        reason: {
-            avgCpu: metrics.cpu?.avg || metrics.cpu?.totalUsage || 0,
-            avgMemory: metrics.memory?.avg_used_pct || metrics.memory?.percentage || 0,
-            message: `Autoscale execution triggered dynamically by AST rule evaluation.`
-        },
-        token: clusterSecret
-    };
-
-    // 1. Broadcast scaling details locally and over the P2P Server Mesh
-    if (serverCtx && typeof serverCtx.send === 'function') {
-        serverCtx.send({
-            method: 'infrastructure.scale',
-            broadcast: true,
-            payload: payload
-        });
+async function shouldScaleOutCluster(telemetry) {
+    const scaleOutCpu = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleOut.cpuThreshold'), 10) || defaults.scaleOut.cpuThreshold;
+    const targetMemory = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleOut.memoryThreshold'), 10) || defaults.scaleOut.memoryThreshold;
+    const maxClusterSize = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleOut.maxClusterSize'), 10) || defaults.scaleOut.maxClusterSize;
 
-        serverCtx.send({
-            method: 'metric.scaleAlert',
-            broadcast: true,
-            direction,
-            metrics: payload.reason
-        });
-    }
+    // STEP 1: Evaluate local Node average across workers
+    const nodeAvg = calculateNodeAverage(telemetry);
+    console.log(`[@cocreate/server-autoscaler] [EVALUATION TIER 1] Node Average -> CPU: ${nodeAvg.avgCpu.toFixed(1)}%, Memory: ${nodeAvg.avgMemory.toFixed(1)}%`);
 
-    // 2. Render highly visible console warning banners for local simulations
-    console.log(`\n=============================================================================`);
-    console.log(`[AUTOSCALER ALERT] DYNAMIC RESOURCE SCALE TRIGGERED`);
-    console.log(`=============================================================================`);
-    console.log(`* ACTION DIRECTION : ${direction.toUpperCase()}`);
-    console.log(`* TARGET REGION    : ${payload.region.toUpperCase()}`);
-    console.log(`* SYSTEM PROFILE   : ${payload.spec.toUpperCase()}`);
-    console.log(`* INSTANCE METRIC  : CPU [${payload.reason.avgCpu}%], RAM [${payload.reason.avgMemory}%]`);
-    console.log(`* TRIGGER MESSAGE  : ${payload.reason.message}`);
-    console.log(`=============================================================================`);
+    const isNodeOverloaded = nodeAvg.avgCpu >= scaleOutCpu || nodeAvg.avgMemory >= targetMemory;
 
-    console.log(`[@cocreate/server-autoscaler] [ACTION] Dispatching AST scaling payload to endpoint: ${targetUrl}`);
+    if (!isNodeOverloaded) {
+        console.log(`[@cocreate/server-autoscaler] [EVALUATION TIER 1] Node average is below thresholds. Cordoning worker is sufficient. Scaling out CANCELLED.`);
+        return false;
+    }
 
-    try {
-        const urlObj = new URL(targetUrl);
-        const options = {
-            hostname: urlObj.hostname,
-            port: urlObj.port || 443,
-            path: urlObj.pathname + urlObj.search,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Content-Length': Buffer.byteLength(JSON.stringify(payload))
-            },
-            timeout: 5000 // Limit network stall times
-        };
+    // STEP 2: Evaluate Cluster capacity across all running servers in DB
+    console.log(`[@cocreate/server-autoscaler] [EVALUATION TIER 2] Node is overloaded. Querying DB for active cluster details...`);
+    const clusterData = await getClusterDetails();
 
-        return await new Promise((resolve, reject) => {
-            const req = https.request(options, (res) => {
-                let body = '';
-                res.on('data', (chunk) => body += chunk);
-                res.on('end', () => {
-                    if (res.statusCode >= 200 && res.statusCode < 300) {
-                        console.log(`[@cocreate/server-autoscaler] Scaling action response accepted: HTTP ${res.statusCode}`);
-                        resolve(JSON.parse(body));
-                    } else {
-                        reject(new Error(`Scaling HTTP request failed: Status ${res.statusCode}`));
-                    }
-                });
-            });
+    if (clusterData && clusterData.totalCount > 0) {
+        console.log(`[@cocreate/server-autoscaler] [EVALUATION TIER 2] Cluster Average (${clusterData.totalCount} servers) -> CPU: ${clusterData.avgCpu.toFixed(1)}%, Memory: ${clusterData.avgMemory.toFixed(1)}%`);
+        
+        // Check optional hard cluster size ceiling (if configured)
+        if (maxClusterSize > 0 && clusterData.totalCount >= maxClusterSize) {
+            console.warn(`[@cocreate/server-autoscaler] [EVALUATION TIER 2] Max cluster size ceiling reached (${clusterData.totalCount}/${maxClusterSize}). Scaling out CANCELLED.`);
+            return false;
+        }
 
-            req.on('error', reject);
-            req.write(JSON.stringify(payload));
-            req.end();
-        });
-    } catch (err) {
-        console.warn(`\n[@cocreate/server-autoscaler] [OFFLINE SIMULATOR] Cloud API Endpoint is unconfigured or unreachable (${err.message}).`);
-        console.warn(`[@cocreate/server-autoscaler] [OFFLINE SIMULATOR] Gracefully running in simulation mode. scaling action succeeded locally.`);
-        console.log(`=============================================================================\n`);
-        return { simulated: true, status: 'acknowledged', direction };
+        const isClusterOverloaded = clusterData.avgCpu >= scaleOutCpu || clusterData.avgMemory >= targetMemory;
+
+        if (!isClusterOverloaded) {
+            console.log(`[@cocreate/server-autoscaler] [EVALUATION TIER 2] Remaining cluster has adequate capacity. Cordoning will rebalance traffic. Scaling out CANCELLED.`);
+            return false;
+        }
+    } else {
+        console.log(`[@cocreate/server-autoscaler] [EVALUATION TIER 2] Server telemetries unavailable in DB. Proceeding with node-based scaling decision.`);
     }
-}
 
-/**
- * Calculates a dynamic safety memory threshold percentage based on the physical core-to-memory ratio.
- * Ensures the system has enough physical MB of headroom to survive the boot provisioning delay.
- * 
- * @returns {number} Calculated maximum safe memory percentage threshold (capped between 50% and 90%)
- */
-export function calculateDynamicSafetyThreshold() {
-    const coresCount = os.cpus().length;
-    const totalMemoryMb = os.totalmem() / 1024 / 1024;
-    
-    const allocationRatePerCoreMs = 15; // Estimated peak allocation speed in MB/sec under sustained load
-    const bootWindowSeconds = 60;      // Boot delay window for new instances
-    
-    const requiredHeadroomMb = coresCount * allocationRatePerCoreMs * bootWindowSeconds;
-    const headroomPercentage = (requiredHeadroomMb / totalMemoryMb) * 100;
-    
-    const maxSafePercentage = Math.round(100 - headroomPercentage);
-    
-    return Math.max(50, Math.min(90, maxSafePercentage));
+    return true;
 }
 
 /**
- * Queries the shared servers directory database to ensure we can safely remove this node 
- * without bringing the remaining active nodes below our configured minimum bounds.
+ * Evaluates whether it is safe for a node to scale in.
+ * Verifies global minimum limits, regional preservation, and projected cluster capacity.
  * 
- * @returns {boolean} Verified consensus state allowing scale-down
+ * @param {Object} telemetry - Telemetry context frame
+ * @returns {boolean} True if node scale-in is authorized
  */
-async function isClusterSafeToScaleDown() {
-    if (!serverCtx?.crud) {
-        console.warn("[@cocreate/server-autoscaler] Database access layer is unavailable. Scaling down rejected.");
-        return false;
+async function shouldScaleInCluster(telemetry) {
+    const minSize = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleIn.minClusterSize'), 10) || defaults.scaleIn.minClusterSize;
+    const scaleOutCpu = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleOut.cpuThreshold'), 10) || defaults.scaleOut.cpuThreshold;
+    const targetMemory = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleOut.memoryThreshold'), 10) || defaults.scaleOut.memoryThreshold;
+    const preservation = getValueFromObject(autoscaleConfig, 'autoscale.scaleIn.preservation') ?? defaults.scaleIn.preservation;
+
+    // Evaluate geographic preservation if enabled ("continent" | "country" | "region")
+    if (preservation && preservation !== "global") {
+        const localZone = server?.location?.[preservation] || server?.[preservation];
+        if (localZone) {
+            // Targeted query for active servers in this node's geographic zone
+            const zoneClusterData = await getClusterDetails({
+                [`location.${preservation}`]: localZone
+            });
+
+            if (!zoneClusterData || zoneClusterData.totalCount <= 1) {
+                console.log(`[@cocreate/server-autoscaler] [CONSENSUS] Scale-in rejected. Removing this node would leave '${localZone}' with no active nodes (Preservation: ${preservation}).`);
+                return false;
+            }
+        }
     }
 
-    const minSize = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.minClusterSize'), 10) || defaults.minClusterSize;
+    const clusterData = await getClusterDetails();
 
-    try {
-        const readResponse = await serverCtx.crud.send({
-            method: 'object.read',
-            array: 'servers',
-            $filter: {
-                query: { status: 'active' },
-                limit: 0
-            },
-            organization_id: serverCtx.organization_id,
-            host: serverCtx.host
-        });
+    if (!clusterData || clusterData.totalCount <= 1) {
+        console.log(`[@cocreate/server-autoscaler] [CONSENSUS] Scale-in rejected. Insufficient active nodes found.`);
+        return false;
+    }
 
-        const activeServers = normalizePeersList(readResponse);
+    if (clusterData.totalCount <= minSize) {
+        console.log(`[@cocreate/server-autoscaler] [CONSENSUS] Scale-in rejected. Active nodes (${clusterData.totalCount}) is already at or below the minimum cluster limit (${minSize}).`);
+        return false;
+    }
 
-        if (activeServers.length <= minSize) {
-            console.log(`[@cocreate/server-autoscaler] [CONSENSUS] Scale-down rejected. Active nodes (${activeServers.length}) is already at or below the minimum cluster limit (${minSize}).`);
-            return false;
-        }
+    // Calculate projected load on remaining nodes if this node is removed
+    const remainingCount = clusterData.totalCount - 1;
+    const projectedCpu = clusterData.totalCpu / remainingCount;
+    const projectedMemory = clusterData.totalMem / remainingCount;
 
-        console.log(`[@cocreate/server-autoscaler] [CONSENSUS] Scale-down authorized. Cluster contains ${activeServers.length} active nodes (Safe margin: > ${minSize}).`);
-        return true;
-    } catch (err) {
-        console.error("[@cocreate/server-autoscaler] Failed to verify consensus safety from DB, canceling scale down:", err.message);
+    console.log(`[@cocreate/server-autoscaler] [SCALE IN CHECK] Projected remaining cluster load (${remainingCount} servers) -> CPU: ${projectedCpu.toFixed(1)}%, Memory: ${projectedMemory.toFixed(1)}%`);
+
+    if (projectedCpu >= scaleOutCpu || projectedMemory >= targetMemory) {
+        console.log(`[@cocreate/server-autoscaler] [CONSENSUS] Scale-in rejected. Removing this node would push remaining cluster load above scale-out thresholds.`);
         return false;
     }
+
+    console.log(`[@cocreate/server-autoscaler] [CONSENSUS] Average cluster threshold met for scale-in. Scale-in authorized. Node marked for scale in.`);
+    return true;
 }
 
 /**
- * Intercepts high-priority 1-second instantaneous memory alerts and executes fast-track scaling.
+ * Triggers external cloud infrastructure provisioning APIs to add or remove node instances.
+ * Incorporates geographic edge targeting metadata and maxNodesPerTier vertical tier checks.
  * 
- * @param {Object} metricPayload - Real-time metric snapshot collected on the 1-second tick
+ * @param {string} action - 'out' or 'in'
+ * @param {Object} telemetry - Telemetry context frame
+ * @param {Object} meta - Optional metadata specs
  */
-async function processEmergencyAlert(metricPayload) {
-    if (!isRunning) return;
+async function executeScaleAction(action, telemetry, meta = {}) {
+    // If scaling out, calculate target region and determine spec tier using maxNodesPerTier
+    if (action === 'out') {
+        const clients = Array.from(
+            server?.wsManager?.clients?.values() ?? [], 
+            client => client?.clientInfo
+        ).filter(Boolean);
+        
+        const geoTarget = getCloudProvider(clients, autoscaleConfig);    
+        if (geoTarget) {
+            meta.geo = geoTarget;
+            console.log(`[@cocreate/server-autoscaler] Geo-Scaling active. Requesting provision in region: ${geoTarget.targetRegion}`);
+        }
 
-    const cooldownDuration = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.cooldownDurationMs'), 10) || defaults.cooldownDurationMs;
+        // Check regional tier counts against maxNodesPerTier to decide whether to upgrade tier
+        const maxNodesPerTier = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.vertical.maxNodesPerTier'), 10) || defaults.vertical.maxNodesPerTier;
+        const tiers = getValueFromObject(autoscaleConfig, 'autoscale.vertical.tiers') || defaults.vertical.tiers;
+        
+        const targetRegion = geoTarget?.targetRegion || server?.infrastructure?.region || 'default-region';
+        
+        // Targeted query for servers in the specific target infrastructure region
+        const regionalClusterData = await getClusterDetails({
+            'infrastructure.region': targetRegion
+        });
 
-    if (Date.now() - lastScaleOperationTimestamp < cooldownDuration) {
-        return; 
-    }
+        if (regionalClusterData && Array.isArray(regionalClusterData.servers)) {
+            const regionalTierCounts = {};
+            for (const serverRecord of regionalClusterData.servers) {
+                const peerTelemetry = serverRecord.telemetry;
+                const vCPU = peerTelemetry?.cpu?.cores?.length || serverRecord.totalWorkers || 1;
+                const memoryTotalBytes = peerTelemetry?.memory?.total || 0;
+                const memoryGb = memoryTotalBytes > 0 ? Math.round(memoryTotalBytes / (1024 * 1024 * 1024)) : 2;
 
-    const memoryPct = metricPayload.memory?.percentage || 0;
+                const tier = matchTierName(vCPU, memoryGb);
+                regionalTierCounts[tier] = (regionalTierCounts[tier] || 0) + 1;
+            }
 
-    lastScaleOperationTimestamp = Date.now();
-    consecutiveCpuSpikes = 0; 
-    consecutiveLowLoadTicks = 0;
+            let selectedTier = tiers[0]; // Start at smallest tier (e.g., nano)
 
-    console.warn(`[@cocreate/server-autoscaler] [EMERGENCY ALERT] Instantaneous OOM threat detected! Memory: ${memoryPct}%. Initiating immediate fast-track scale-up...`);
-    
-    // Default action configuration for high-priority fast-track memory scale requests
-    const emergencyActionConfig = {
-        method: 'infrastructure.scale',
-        provider: 'round-robin',
-        spec: 'memory-optimized',
-        region: 'local'
-    };
-    await executeScaleAction('up', metricPayload, emergencyActionConfig);
+            for (const tierSpec of tiers) {
+                const countAtTier = regionalTierCounts[tierSpec.name] || 0;
+                if (countAtTier < maxNodesPerTier) {
+                    selectedTier = tierSpec;
+                    break;
+                }
+                // If maxNodesPerTier reached, step up to next tier spec
+                selectedTier = tierSpec;
+            }
+
+            meta.tier = selectedTier;
+            console.log(`[@cocreate/server-autoscaler] Vertical Tiering selected spec '${selectedTier.name}' (${selectedTier.vCPU} vCPU, ${selectedTier.memoryGb} GB RAM) for region '${targetRegion}'.`);
+        }
+    }
+
+    console.log(`[@cocreate/server-autoscaler] Requesting infrastructure scale-${action.toUpperCase()}...`, meta);
+
+    // Emit event across server event bus for infrastructure orchestrator
+    if (server?.emit) {
+        server.emit('telemetry.scaleAction', {
+            action,
+            telemetry,
+            meta,
+            timestamp: Date.now()
+        });
+    }
 }
 
 /**
- * Evaluates the pre-averaged flush packet directly against the threshold limits.
- * Handles both classic properties and advanced declarative AST-configured orchestration rules.
+ * Processes telemetry frame payloads.
+ * - Memory evaluated INSTANTLY on every TICK to protect against sudden heap OOM crashes.
+ * - CPU evaluated across SUSTAINED FLUSHES to avoid over-provisioning on transient spikes.
+ * - Scale down evaluated across DEBOUNCED LOW FLUSHES.
  * 
- * @param {Object} metricPayload - Normalized metrics data frame received on flush
+ * @param {Object} telemetry - Telemetry frame payload received on tick or flush dispatch
  */
-async function processMetricFlush(metricPayload) {
+async function processTelemetryFrame(telemetry) {
     if (!isRunning) return;
 
-    const scaleUpCpu = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleUpCpuThreshold'), 10) || defaults.scaleUpCpuThreshold;
-    const scaleUpCpuExtreme = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleUpCpuExtremeThreshold'), 10) || defaults.scaleUpCpuExtremeThreshold;
-    const scaleDownCpu = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleDownCpuThreshold'), 10) || defaults.scaleDownCpuThreshold;
-    const cooldownDuration = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.cooldownDurationMs'), 10) || defaults.cooldownDurationMs;
-    const spikesRequired = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.consecutiveCpuSpikesRequired'), 10) || defaults.consecutiveCpuSpikesRequired;
-    const lowTicksRequired = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.consecutiveLowTicksRequired'), 10) || defaults.consecutiveLowTicksRequired;
+    const scaleOutCpu = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleOut.cpuThreshold'), 10) || defaults.scaleOut.cpuThreshold;
+    const scaleInCpu = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleIn.cpuThreshold'), 10) || defaults.scaleIn.cpuThreshold;
+    const targetMemoryThreshold = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleOut.memoryThreshold'), 10) || defaults.scaleOut.memoryThreshold;
+    const scaleInMemory = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleIn.memoryThreshold'), 10) || defaults.scaleIn.memoryThreshold;
+    const spikesRequired = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleOut.consecutiveFlushes'), 10) || defaults.scaleOut.consecutiveFlushes;
+    const lowFlushesRequired = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleIn.consecutiveFlushes'), 10) || defaults.scaleIn.consecutiveFlushes;
 
-    let targetMemoryThreshold = parseInt(getValueFromObject(autoscaleConfig, 'autoscale.scaleUpMemoryThreshold'), 10) || defaults.scaleUpMemoryThreshold;
+    const cpuAvg = telemetry.cpu?.totalUsage || 0;
+    const memoryAvg = telemetry.memory?.percentage || 0;
 
-    const isSafetyLimitsEnabled = getValueFromObject(autoscaleConfig, 'autoscale.safetyLimits') !== false && getValueFromObject(autoscaleConfig, 'autoscale.safetyLimits') !== 'false';
-    
-    if (isSafetyLimitsEnabled) {
-        const dynamicSafetyThreshold = calculateDynamicSafetyThreshold();
-        if (targetMemoryThreshold > dynamicSafetyThreshold) {
-            console.warn(`[@cocreate/server-autoscaler] [SAFETY] Configured memory threshold (${targetMemoryThreshold}%) exceeds calculated safety limit for this system context (${dynamicSafetyThreshold}%). Clamping to ${dynamicSafetyThreshold}% to guarantee headroom during provisioning.`);
-            targetMemoryThreshold = dynamicSafetyThreshold;
-        }
-    }
+    // TRACK 1: INSTANT PER-TICK MEMORY EVALUATION
+    const isMemoryPeaked = memoryAvg >= targetMemoryThreshold;
 
-    if (Date.now() - lastScaleOperationTimestamp < cooldownDuration) {
-        return; 
-    }
+    if (isMemoryPeaked) {
+        console.warn(`[@cocreate/server-autoscaler] [INSTANT TICK] Memory threshold exceeded (${memoryAvg}% >= limit: ${targetMemoryThreshold}%). Triggering immediate worker cordon & scale evaluation...`);
+        
+        cordonWorkerNode(telemetry);
 
-    const cpuAvg = metricPayload.cpu?.avg || 0;
-    const memoryAvg = metricPayload.memory?.avg_used_pct || 0;
+        const authorized = await shouldScaleOutCluster(telemetry);
+        if (authorized) {
+            consecutiveCpuSpikes = 0;
+            await executeScaleAction('out', telemetry, { spec: 'memory-optimized', trigger: 'memory-instant-tick' });
+        }
+        return;
+    }
 
-    // Maintain and increment state accumulators
-    if (cpuAvg >= scaleUpCpu) {
+    // TRACK 2: SUSTAINED FLUSH-BASED CPU EVALUATION
+    if (cpuAvg >= scaleOutCpu) {
         consecutiveCpuSpikes++;
-        consecutiveLowLoadTicks = 0; 
+        consecutiveLowLoadFlushes = 0; 
     } else {
         consecutiveCpuSpikes = 0; 
     }
 
-    const isUnderloaded = cpuAvg <= scaleDownCpu && memoryAvg < (targetMemoryThreshold * 0.6);
+    const isUnderloaded = cpuAvg <= scaleInCpu && memoryAvg <= scaleInMemory;
 
     if (isUnderloaded) {
-        consecutiveLowLoadTicks++;
+        consecutiveLowLoadFlushes++;
     } else {
-        consecutiveLowLoadTicks = 0;
+        consecutiveLowLoadFlushes = 0;
     }
 
-    // Build the consolidated evaluation context for the AST interpreter
-    const evaluationContext = {
-        ...metricPayload,
-        consecutiveCpuSpikes,
-        consecutiveLowLoadTicks
-    };
+    const isCpuSustainedPeak = consecutiveCpuSpikes >= spikesRequired;
 
-    // Retrieve potential AST orchestration rules from configuration
-    const customOrchestrationRule = getValueFromObject(autoscaleConfig, 'autoscale.orchestrationRule');
+    if (isCpuSustainedPeak) {
+        console.warn(`[@cocreate/server-autoscaler] [SUSTAINED FLUSH] Sustained CPU threshold exceeded for ${consecutiveCpuSpikes} consecutive flushes (${cpuAvg}% >= limit: ${scaleOutCpu}%). Triggering worker cordon & scale evaluation...`);
 
-    if (customOrchestrationRule) {
-        // --- DECLARATIVE AST EXECUTION TRACK ---
-        console.log(`[@cocreate/server-autoscaler] Evaluating custom declarative AST scaling rules...`);
-        
-        const isTriggered = evaluateAST(customOrchestrationRule, evaluationContext);
-        
-        if (isTriggered) {
-            const actionNode = customOrchestrationRule.action || {};
-            lastScaleOperationTimestamp = Date.now();
-            consecutiveCpuSpikes = 0;
-            consecutiveLowLoadTicks = 0;
-
-            console.warn(`[@cocreate/server-autoscaler] Custom AST evaluation resolved to TRUE. Triggering custom scaled action...`);
-            await executeScaleAction('up', metricPayload, actionNode);
-            return;
-        }
-    } else {
-        // --- TRADITIONAL DUAL-TRACK HARDCODED FALLBACK ---
-        const isMemoryPeaked = memoryAvg >= targetMemoryThreshold; 
-        const isCpuExtremePeak = cpuAvg >= scaleUpCpuExtreme;     
-        const isCpuSustainedPeak = consecutiveCpuSpikes >= spikesRequired;
-
-        if (isCpuExtremePeak || isCpuSustainedPeak || isMemoryPeaked) {
-            let triggerReason = '';
-            let targetSpec = 'standard';
-
-            if (isMemoryPeaked) {
-                triggerReason = `Incompressible memory threshold exceeded (${memoryAvg}% >= limit: ${targetMemoryThreshold}%)`;
-                targetSpec = 'memory-optimized';
-            } else if (isCpuExtremePeak) {
-                triggerReason = `Extreme CPU ceiling exceeded on a single flush (${cpuAvg}% >= limit: ${scaleUpCpuExtreme}%)`;
-                targetSpec = 'compute-optimized';
-            } else {
-                triggerReason = `Sustained CPU threshold exceeded for ${consecutiveCpuSpikes} consecutive cycles (${cpuAvg}% >= limit: ${scaleUpCpu}%)`;
-                targetSpec = 'compute-optimized';
-            }
+        cordonWorkerNode(telemetry);
 
-            lastScaleOperationTimestamp = Date.now();
+        const authorized = await shouldScaleOutCluster(telemetry);
+        if (authorized) {
             consecutiveCpuSpikes = 0; 
-
-            console.warn(`[@cocreate/server-autoscaler] Peak limit hit! ${triggerReason}. Scaling up...`);
-            await executeScaleAction('up', metricPayload, { spec: targetSpec });
-            return;
+            await executeScaleAction('out', telemetry, { spec: 'compute-optimized', trigger: 'cpu-sustained-flushes' });
         }
+        return;
     }
 
-    // Scale Down evaluation track: Consolidated across both AST and traditional modes
-    if (consecutiveLowLoadTicks >= lowTicksRequired) {
-        console.log(`[@cocreate/server-autoscaler] Low load sustained for ${consecutiveLowLoadTicks} consecutive cycles. Checking cluster state to verify consensus...`);
+    // TRACK 3: SCALE IN EVALUATION (SUSTAINED LOW LOAD ACROSS FLUSHES)
+    if (consecutiveLowLoadFlushes >= lowFlushesRequired) {
+        console.log(`[@cocreate/server-autoscaler] Low load sustained for ${consecutiveLowLoadFlushes} consecutive flushes. Checking cluster state to verify consensus...`);
         
-        const safeToScaleDown = await isClusterSafeToScaleDown();
-        if (safeToScaleDown) {
-            lastScaleOperationTimestamp = Date.now();
-            consecutiveLowLoadTicks = 0; 
+        const safeToScaleIn = await shouldScaleInCluster(telemetry);
+        if (safeToScaleIn) {
+            consecutiveLowLoadFlushes = 0; 
             
-            console.log(`[@cocreate/server-autoscaler] Safe-down consensus verified. Scaling down...`);
-            await executeScaleAction('down', metricPayload);
+            console.log(`[@cocreate/server-autoscaler] Safe-in consensus verified. Scaling in...`);
+            await executeScaleAction('in', telemetry);
         } else {
-            consecutiveLowLoadTicks = Math.round(lowTicksRequired / 2); 
+            consecutiveLowLoadFlushes = Math.round(lowFlushesRequired / 2); 
         }
     }
 }
@@ -433,71 +395,50 @@ async function processMetricFlush(metricPayload) {
 /**
  * Boots the autoscaler system exclusively on the Master/Primary process context.
  * 
- * @param {Object} server - Central CoCreateServer instance references
+ * @param {Object} serverInstance - Central CoCreateServer instance references
  * @returns {Object} Active autoscale control API
  */
-export async function init(server) {
-    if (!isPrimary) {
-        throw new Error("[@cocreate/server-autoscaler] [FATAL] Violation of scope: ServerAutoscaler can only run on the Primary (Master) process.");
+export async function init(serverInstance) {
+    server = serverInstance;
+    
+    if (!isMaster) {
+        console.log('[@cocreate/server-autoscaler] Autoscaler initialized on worker node (Standby).');
+        return;
     }
 
-    serverCtx = server;
-
-    autoscaleConfig = await Config({
-        'autoscale': ''
-    });
+    try {
+        autoscaleConfig = await Config.get('autoscale');
+    } catch (e) {
+        console.warn('[@cocreate/server-autoscaler] Failed to load config, falling back to defaults.', e.message);
+        autoscaleConfig = {};
+    }
 
     const isEnabled = getValueFromObject(autoscaleConfig, 'autoscale.enabled') !== false && getValueFromObject(autoscaleConfig, 'autoscale.enabled') !== 'false';
 
     if (!isEnabled) {
-        console.log('[@cocreate/server-autoscaler] ServerAutoscaler is disabled by configuration.');
-        return { init, stop };
+        console.log('[@cocreate/server-autoscaler] Autoscaling is disabled by configuration.');
+        return;
     }
 
     isRunning = true;
-    
-    consecutiveCpuSpikes = 0;
-    consecutiveLowLoadTicks = 0;
 
-    serverCtx.on('metric', (payload) => {
-        if (payload && payload.data) {
-            processMetricFlush(payload.data).catch(err => {
-                console.error("[@cocreate/server-autoscaler] Error processing autoscale execution tick:", err);
-            });
-        }
+    // Subscribe to incoming telemetry frame dispatches published by server-telemetry.js
+    server.on('telemetry', (telemetry) => {
+        processTelemetryFrame(telemetry);
     });
 
-    serverCtx.on('metric.emergency', (payload) => {
-        if (payload && payload.data) {
-            processEmergencyAlert(payload.data).catch(err => {
-                console.error("[@cocreate/server-autoscaler] Error processing emergency autoscale trigger:", err);
-            });
-        }
-    });
-
-    console.log('[@cocreate/server-autoscaler] Autoscaler initialized and subscribed to telemetry feed.');
-
-    return {
-        init,
-        stop,
-        processMetricFlush,
-        processEmergencyAlert,
-        executeScaleAction,
-        calculateDynamicSafetyThreshold
-    };
+    console.log('[@cocreate/server-autoscaler] Initialized and listening for telemetry on Master node.');
 }
 
 /**
- * Terminates monitoring sweeps and unsubscribes from the process emitter.
+ * Halts any active autoscaler processing
  */
 export function stop() {
     isRunning = false;
-    consecutiveCpuSpikes = 0;
-    consecutiveLowLoadTicks = 0;
-    console.log('[@cocreate/server-autoscaler] ServerAutoscaler monitoring stopped.');
+    console.log('[@cocreate/server-autoscaler] Execution loop halted.');
 }
 
-export default {
-    init,
-    stop
+export default { 
+    init, 
+    stop 
 };