@calltelemetry/ct-lab-mcp 0.8.64 → 0.8.66

package/dist/src/slot/manager.js

@@ -1,11 +1,12 @@
 /**
- * Global Slot Allocation & Capacity Partitioning Engine
- * Manages 8GB appliance slots across Proxmox VE and VMware ESXi hosts with hard partition limits,
+ * Resource-based Slot Allocation Engine
+ * Manages identity-bound appliance leases using fresh physical resource admission,
  * atomic concurrency locking (AsyncMutex), TTL lease management, candidate slot ranking,
  * structured metadata labeling/indexing, and automated expired slot purge & reclamation.
  */
 import { createHash, randomInt, randomUUID } from "node:crypto";
 import { CapacityExceededError, GlobalCapacityExceededError, SlotNotFoundError, LeaseCeilingExceededError, InvalidSlotOperationError, DatastoreCapacityExceededError, HypervisorSlotUnsupportedError, CubeNotFoundError, CubeAlreadyClaimedError } from "./types.js";
+import { ProxmoxDriver } from "../hypervisors/proxmox/client.js";
 import { AsyncMutex } from "../utils/mutex.js";
 import { defaultSafetyGuardrailEngine } from "../guardrails/safety.js";
 import { telemetry } from "../telemetry/index.js";
@@ -16,17 +17,10 @@ export * from "./types.js";
  * Capacity is derived directly from unreserved physical RAM: (total - reserved) / slotSize.
  */
 export function calculatePureCapacity(host) {
-    if (host.maxSlots !== undefined) {
-        if (host.hypervisorType === "esxi" && host.maxSlots === 0 && host.allowEsxiSlots) {
-            // Allow dynamic calculation below for ESXi when unlocked
-        }
-        else {
-            return host.maxSlots;
-        }
-    }
-    const slotSize = host.slotSizeMb || 8192;
-    if (host.totalMemoryMb !== undefined) {
-        const reserved = host.reservedHeadroomMb || 0;
+    const slotSize = host.slotSizeMb ?? 8192;
+    const reserved = host.reservedHeadroomMb ?? 0;
+    if (Number.isFinite(host.totalMemoryMb) && Number.isFinite(slotSize) && slotSize > 0
+        && Number.isFinite(reserved) && reserved >= 0) {
         const usableMb = Math.max(0, host.totalMemoryMb - reserved);
         return Math.floor(usableMb / slotSize);
     }
@@ -37,36 +31,26 @@ const DEFAULT_HOST_CONFIGS = [
         hostId: "proxmox-lab",
         name: "Proxmox Lab (Primary)",
         hypervisorType: "proxmox",
-        totalMemoryMb: 32768, // 32 GB
-        reservedHeadroomMb: 16384, // 16 GB reserved for CUCM and system
-        maxSlots: 2, // Pure capacity: 2 slots (16 GB usable)
+        totalMemoryMb: 0, // Unknown until a fresh hypervisor read
+        reservedHeadroomMb: 0,
         slotSizeMb: 8192, // 8 GB per slot
-        freeDiskGb: 280,
-        totalDiskGb: 500
     },
     {
         hostId: "proxmox-mini",
         name: "Proxmox Mini (Minisforum)",
         hypervisorType: "proxmox",
-        totalMemoryMb: 65536, // 64 GB
-        reservedHeadroomMb: 32768, // 32 GB reserved
-        maxSlots: 4, // Pure capacity: 4 slots (32 GB usable)
+        totalMemoryMb: 0,
+        reservedHeadroomMb: 0,
         slotSizeMb: 8192, // 8 GB per slot
-        freeDiskGb: 650,
-        totalDiskGb: 1000
     }
 ];
 export const DEFAULT_ESXI_HOST_CONFIG = {
     hostId: "esxi-intel-192-168-123-176",
     name: "ESXi Intel Lab (192.168.123.176)",
     hypervisorType: "esxi",
-    totalMemoryMb: 131072, // 128 GB
-    reservedHeadroomMb: 65536, // 64 GB reserved
-    maxSlots: 0, // Hard limit: 0 slots (slot leasing disabled on ESXi)
+    totalMemoryMb: 0,
+    reservedHeadroomMb: 0,
     slotSizeMb: 8192,
-    freeDiskGb: 1200,
-    totalDiskGb: 1860,
-    datastoreFreeBytes: 1200 * 1024 * 1024 * 1024
 };
 export const DEFAULT_CUBES = [
     {
@@ -119,6 +103,7 @@ export class SlotManager {
     guardrailEngine;
     telemetry;
     allowEsxiSlots;
+    capacityReader;
     constructor(options = {}) {
         this.defaultDurationMinutes = options.defaultDurationMinutes ?? 120;
         this.proxmoxManager = options.proxmoxManager;
@@ -126,6 +111,7 @@ export class SlotManager {
         this.guardrailEngine = options.guardrailEngine || defaultSafetyGuardrailEngine;
         this.telemetry = options.telemetryRegistry || telemetry;
         this.allowEsxiSlots = options.allowEsxiSlots ?? (process.env.ALLOW_ESXI_SLOTS === "true");
+        this.capacityReader = options.capacityReader;
         const hostConfigs = options.hosts && options.hosts.length > 0
             ? options.hosts
             : [...DEFAULT_HOST_CONFIGS];
@@ -152,60 +138,136 @@ export class SlotManager {
         this.guardrailEngine = guardrailEngine;
     }
     /**
-     * Register a host and initialize its slot definitions.
+     * Register host identity. Leases are created on demand after resource admission.
      */
     registerHost(host) {
         const normalizedId = this.normalizeHostId(host.hostId);
-        let pureSlots = calculatePureCapacity({
-            ...host,
-            allowEsxiSlots: this.allowEsxiSlots
-        });
-        if (normalizedId.startsWith("esxi") && this.allowEsxiSlots && host.maxSlots === 0) {
-            const usableMb = Math.max(0, host.totalMemoryMb - (host.reservedHeadroomMb || 0));
-            pureSlots = Math.floor(usableMb / (host.slotSizeMb || 8192));
-        }
         const normalizedHost = {
             ...host,
             hostId: normalizedId,
-            maxSlots: pureSlots,
             hypervisorType: host.hypervisorType || (normalizedId.startsWith("esxi") ? "esxi" : "proxmox")
         };
         this.hosts.set(normalizedId, normalizedHost);
-        for (let index = 1; index <= pureSlots; index++) {
-            const slotId = `slot-${normalizedId}-${index}`;
-            if (!this.slots.has(slotId)) {
-                this.slots.set(slotId, {
-                    slotId,
-                    hostId: normalizedId,
-                    hostName: normalizedHost.name,
-                    hypervisorType: normalizedHost.hypervisorType,
-                    slotIndex: index,
-                    memoryMb: normalizedHost.slotSizeMb,
-                    allocatedMemoryMb: normalizedHost.slotSizeMb,
-                    allocatedMemoryBytes: normalizedHost.slotSizeMb * 1024 * 1024,
-                    status: "AVAILABLE",
-                    claimId: null,
-                    claimedAt: null,
-                    expiresAt: null,
-                    durationMinutes: null,
-                    ttlMinutes: null,
-                    ttlSeconds: null,
-                    tag: null,
-                    label: null,
-                    workloadType: null,
-                    targetVersion: null,
-                    branch: null,
-                    customTags: [],
-                    requester: null,
-                    linearIssue: null,
-                    sessionId: null,
-                    purpose: null,
-                    vmId: null,
-                    vmName: null,
-                    metadata: {}
-                });
+    }
+    createAvailableSlot(host, reuse = true) {
+        const hostSlots = Array.from(this.slots.values()).filter((slot) => slot.hostId === host.hostId);
+        const existing = hostSlots.find((slot) => slot.status === "AVAILABLE");
+        if (reuse && existing)
+            return existing;
+        const index = Math.max(0, ...hostSlots.map((slot) => slot.slotIndex)) + 1;
+        const slotId = `slot-${host.hostId}-${index}`;
+        const slot = {
+            slotId,
+            hostId: host.hostId,
+            hostName: host.name,
+            hypervisorType: host.hypervisorType,
+            slotIndex: index,
+            memoryMb: host.slotSizeMb,
+            allocatedMemoryMb: host.slotSizeMb,
+            allocatedMemoryBytes: host.slotSizeMb * 1024 * 1024,
+            status: "AVAILABLE",
+            claimId: null,
+            claimedAt: null,
+            expiresAt: null,
+            durationMinutes: null,
+            ttlMinutes: null,
+            ttlSeconds: null,
+            tag: null,
+            label: null,
+            workloadType: null,
+            targetVersion: null,
+            branch: null,
+            customTags: [],
+            requester: null,
+            linearIssue: null,
+            sessionId: null,
+            purpose: null,
+            vmId: null,
+            vmName: null,
+            metadata: {}
+        };
+        this.slots.set(slotId, slot);
+        return slot;
+    }
+    /** Fresh reads are the only admission authority; registered sizes are diagnostics. */
+    async readHostResources(host, storage, omitClaimId) {
+        const observedAt = new Date().toISOString();
+        const unknown = { status: "unknown", freeMemoryMb: 0, freeDiskGb: 0,
+            totalMemoryMb: 0, totalDiskGb: 0, cpuTotalCores: 0, observedAt };
+        try {
+            let driver;
+            try {
+                driver = this.hypervisorManager?.getDriver(host.hostId)
+                    ?? (this.proxmoxManager && host.hypervisorType === "proxmox"
+                        ? new ProxmoxDriver(this.proxmoxManager.getHostConfig(host.hostId), this.proxmoxManager.getClient(host.hostId)) : undefined);
+            }
+            catch (error) {
+                // A trusted injected reader can supply offline telemetry without a
+                // driver. Production has no reader/config fallback and still refuses.
+                if (!this.capacityReader)
+                    throw error;
+            }
+            const reading = this.capacityReader
+                ? await this.capacityReader(host.hostId)
+                : await driver?.getHostCapacity();
+            const capacity = reading ? { ...reading } : undefined;
+            if (!capacity || this.normalizeHostId(capacity.name) !== host.hostId
+                || capacity.type !== host.hypervisorType)
+                return unknown;
+            if (storage) {
+                const pool = (await driver?.listStorage?.())?.find((pool) => pool.storage === storage
+                    && pool.active && pool.enabled && pool.content.split(",").includes("images"));
+                if (!pool)
+                    return unknown;
+                capacity.storageTotalBytes = pool.totalBytes;
+                capacity.storageFreeBytes = pool.availableBytes;
+            }
+            const numbers = [capacity.memoryTotalBytes, capacity.memoryFreeBytes,
+                capacity.storageTotalBytes, capacity.storageFreeBytes, capacity.cpuTotalCores];
+            if (numbers.some((value) => !Number.isFinite(value) || value < 0)
+                || capacity.memoryTotalBytes <= 0 || capacity.storageTotalBytes <= 0 || capacity.cpuTotalCores <= 0
+                || capacity.memoryFreeBytes > capacity.memoryTotalBytes
+                || capacity.storageFreeBytes > capacity.storageTotalBytes)
+                return unknown;
+            if (capacity.status !== "online")
+                return { ...unknown, status: capacity.status };
+            // Free RAM/disk already includes running, attached VMs. Pending or stopped
+            // claims reserve their requested size under the same claim mutex, so a
+            // concurrent read cannot promise the same physical resources twice.
+            const occupied = Array.from(this.slots.values()).filter((slot) => slot.hostId === host.hostId && slot.status !== "AVAILABLE" && slot.claimId !== omitClaimId);
+            let runningIds = new Set();
+            let attachedIds = new Set();
+            if (driver && occupied.some((slot) => slot.vmId != null)) {
+                try {
+                    const vms = await driver.listVms();
+                    attachedIds = new Set(vms.map((vm) => String(vm.id)));
+                    runningIds = new Set(vms.filter((vm) => vm.status === "running").map((vm) => String(vm.id)));
+                }
+                catch { /* Unknown attachment remains conservatively reserved. */ }
             }
+            const reservedMemoryMb = occupied.reduce((sum, slot) => sum + (slot.vmId != null && runningIds.has(String(slot.vmId)) ? 0 : slot.memoryMb), 0);
+            const reservedDiskGb = occupied.reduce((sum, slot) => sum + (slot.vmId != null && attachedIds.has(String(slot.vmId)) ? 0 : slot.allocatedDiskGb ?? 10), 0);
+            return {
+                status: "online",
+                freeMemoryMb: Math.max(0, capacity.memoryFreeBytes / (1024 * 1024) - reservedMemoryMb),
+                freeDiskGb: Math.max(0, capacity.storageFreeBytes / (1024 ** 3) - reservedDiskGb),
+                totalMemoryMb: capacity.memoryTotalBytes / (1024 * 1024),
+                totalDiskGb: capacity.storageTotalBytes / (1024 ** 3),
+                cpuTotalCores: capacity.cpuTotalCores,
+                observedAt,
+            };
         }
+        catch {
+            return unknown;
+        }
+    }
+    availableResourceUnits(resources, memoryMb, diskGb = 10, cpuCores = 1) {
+        if (resources.status !== "online" || !Number.isFinite(memoryMb) || memoryMb <= 0
+            || !Number.isFinite(diskGb) || diskGb <= 0 || !Number.isFinite(cpuCores)
+            || cpuCores <= 0 || cpuCores > resources.cpuTotalCores)
+            return 0;
+        const units = Math.floor(Math.min(resources.freeMemoryMb / memoryMb, resources.freeDiskGb / diskGb));
+        return Number.isSafeInteger(units) && units >= 0 ? units : 0;
     }
     /**
      * Normalizes host ID strings (e.g. mapping aliases like proxmox-minis-lab -> proxmox-mini).
@@ -299,6 +361,30 @@ export class SlotManager {
     async claimSlot(request) {
         return this.mutex.runExclusive(async () => this.claimSlotInternal(request));
     }
+    /** Recheck the exact size immediately before public claim creation/provisioning. */
+    async assertProvisionResources(hostId, request) {
+        return this.mutex.runExclusive(async () => {
+            const host = this.hosts.get(this.normalizeHostId(hostId));
+            if (!host)
+                throw new InvalidSlotOperationError(`Unknown provisioning host '${hostId}'.`);
+            const claim = request.claimId ? Array.from(this.slots.values())
+                .find((slot) => slot.claimId === request.claimId) : undefined;
+            if (request.claimId && (!claim || claim.hostId !== host.hostId
+                || (claim.status !== "CLAIMED" && claim.status !== "active")
+                || !claim.expiresAt || !Number.isFinite(Date.parse(claim.expiresAt))
+                || Date.parse(claim.expiresAt) <= Date.now()
+                || (request.linearIssue && claim.linearIssue && request.linearIssue !== claim.linearIssue))) {
+                throw new InvalidSlotOperationError("Provisioning requires the exact active, unexpired claim on the requested host and issue.");
+            }
+            if (claim && (request.memoryMb > claim.memoryMb || request.diskGb > (claim.allocatedDiskGb ?? 10))) {
+                throw new InvalidSlotOperationError("Requested guest size exceeds the existing lease reservation; acquire a size-matched claim.");
+            }
+            const resources = await this.readHostResources(host, request.storage, request.claimId);
+            if (this.availableResourceUnits(resources, request.memoryMb, request.diskGb, request.cpuCores) < 1) {
+                throw new CapacityExceededError(`Host '${host.hostId}' lacks verified resources for the requested guest size (capacity ${resources.status}).`, host.hostId);
+            }
+        });
+    }
     async claimSlotInternal(request) {
         // 1. Reclaim any expired leases first
         this.sweepExpiredSlotsInternal();
@@ -310,7 +396,7 @@ export class SlotManager {
         if (durationMinutes < 1 || durationMinutes > 1440) {
             throw new InvalidSlotOperationError(`Claim duration must be between 1 and 1440 minutes (requested: ${durationMinutes}).`);
         }
-        const rawRequestedHost = request.host || request.targetHost;
+        const rawRequestedHost = request.host && request.host !== "auto" ? request.host : request.targetHost || request.host;
         const requestedHost = rawRequestedHost ? this.normalizeHostId(rawRequestedHost) : undefined;
         const hypervisorTypePref = request.hypervisorType || "any";
         const allowEsxi = request.allowEsxiSlots ?? this.allowEsxiSlots;
@@ -327,162 +413,72 @@ export class SlotManager {
                 throw new HypervisorSlotUnsupportedError("Slot leasing is not supported on ESXi hypervisors. Appliance slots are exclusively managed on Proxmox VE (proxmox-lab and proxmox-mini).", requestedHost, "esxi");
             }
         }
-        let targetSlot;
-        if (requestedHost && requestedHost !== "auto") {
-            // Specific host claim
-            const hostConfig = this.hosts.get(requestedHost);
-            if (!hostConfig) {
-                const validHosts = Array.from(this.hosts.keys()).join(", ");
-                throw new InvalidSlotOperationError(`Unknown host '${requestedHost}' for slot allocation. Available: [${validHosts}]`);
-            }
-            // ESXi Datastore check (>= 10GB free required)
-            if (hostConfig.hypervisorType === "esxi") {
-                const freeDisk = hostConfig.freeDiskGb ?? 100;
-                if (freeDisk < 10) {
-                    throw new DatastoreCapacityExceededError(requestedHost, 10, freeDisk);
-                }
-            }
-            const hostSlots = Array.from(this.slots.values())
-                .filter((s) => s.hostId === requestedHost)
-                .sort((a, b) => a.slotIndex - b.slotIndex);
-            let availableSlot = hostSlots.find((s) => s.status === "AVAILABLE");
-            // Dynamic slot expansion when box pure capacity exceeds pre-allocated slots
-            if (!availableSlot) {
-                const pureSlots = calculatePureCapacity(hostConfig);
-                if (hostSlots.length < pureSlots) {
-                    const nextIndex = hostSlots.length + 1;
-                    const slotId = `slot-${requestedHost}-${nextIndex}`;
-                    availableSlot = {
-                        slotId,
-                        hostId: requestedHost,
-                        hostName: hostConfig.name,
-                        hypervisorType: hostConfig.hypervisorType,
-                        slotIndex: nextIndex,
-                        memoryMb: hostConfig.slotSizeMb || 8192,
-                        allocatedMemoryMb: hostConfig.slotSizeMb || 8192,
-                        allocatedMemoryBytes: (hostConfig.slotSizeMb || 8192) * 1024 * 1024,
-                        status: "AVAILABLE",
-                        claimId: null,
-                        claimedAt: null,
-                        expiresAt: null,
-                        durationMinutes: null,
-                        ttlMinutes: null,
-                        ttlSeconds: null,
-                        tag: null,
-                        label: null,
-                        workloadType: null,
-                        targetVersion: null,
-                        branch: null,
-                        customTags: [],
-                        requester: null,
-                        linearIssue: null,
-                        sessionId: null,
-                        purpose: null,
-                        vmId: null,
-                        vmName: null,
-                        metadata: {}
-                    };
-                    this.slots.set(slotId, availableSlot);
-                    hostSlots.push(availableSlot);
-                }
-            }
-            if (!availableSlot && request.purgeIfFull) {
-                const purgeRes = await this.purgeSlotsInternal({
-                    host: requestedHost,
-                    destroyVms: true,
-                    includeOrphans: true,
-                    dryRun: false
-                });
-                if (purgeRes.purgedSlotsCount > 0 || purgeRes.destroyedVmsCount > 0) {
-                    const recheckedSlots = Array.from(this.slots.values())
-                        .filter((s) => s.hostId === requestedHost)
-                        .sort((a, b) => a.slotIndex - b.slotIndex);
-                    availableSlot = recheckedSlots.find((s) => s.status === "AVAILABLE");
-                }
-            }
-            if (!availableSlot) {
-                const allocatedCount = hostSlots.filter((s) => s.status === "CLAIMED" || s.status === "active").length;
-                const hostLimit = hostConfig.maxSlots ?? calculatePureCapacity(hostConfig);
-                if (requestedHost === "proxmox-lab") {
-                    throw new CapacityExceededError(`Host 'proxmox-lab' has reached its hard quota limit of 2 concurrent 8GB slots (16GB allocated). 16GB is strictly reserved for CUCM and core lab infrastructure.`, "proxmox-lab", hostLimit, allocatedCount);
-                }
-                else if (requestedHost === "proxmox-mini") {
-                    throw new CapacityExceededError(`Host 'proxmox-mini' has reached its hard quota limit of 4 concurrent 8GB slots (32GB allocated).`, "proxmox-mini", hostLimit, allocatedCount);
-                }
-                else {
-                    throw new CapacityExceededError(`Host '${requestedHost}' has reached its hard quota limit of ${hostLimit} concurrent slots.`, requestedHost, hostLimit, allocatedCount);
-                }
+        const memoryMb = request.slotSizeMb ?? 8192;
+        const diskGb = request.diskGb ?? 10;
+        const cpuCores = request.cpuCores ?? 1;
+        if (!Number.isFinite(memoryMb) || memoryMb <= 0 || !Number.isFinite(diskGb) || diskGb <= 0) {
+            throw new InvalidSlotOperationError("Requested memory and disk must be positive finite sizes.");
+        }
+        const diskForHost = (hostId) => request.hostDiskGb?.[hostId] ?? diskGb;
+        if (request.hostDiskGb && Object.values(request.hostDiskGb).some((size) => !Number.isFinite(size) || size <= 0)) {
+            throw new InvalidSlotOperationError("Inherited per-host disk profiles must be positive finite sizes.");
+        }
+        const candidates = Array.from(this.hosts.values()).filter((host) => {
+            if (request.hostDiskGb && !(host.hostId in request.hostDiskGb))
+                return false;
+            if (requestedHost && requestedHost !== "auto" && host.hostId !== requestedHost)
+                return false;
+            if (host.hypervisorType === "esxi" && !allowEsxi)
+                return false;
+            if (hypervisorTypePref === "proxmox" && host.hypervisorType !== "proxmox")
+                return false;
+            if (hypervisorTypePref === "esxi" && host.hypervisorType !== "esxi")
+                return false;
+            return true;
+        });
+        if (requestedHost && requestedHost !== "auto" && !this.hosts.has(requestedHost)) {
+            throw new InvalidSlotOperationError(`Unknown host '${requestedHost}' for slot allocation.`);
+        }
+        const readCandidates = () => Promise.all(candidates.map(async (host) => ({
+            host, diskGb: diskForHost(host.hostId), resources: await this.readHostResources(host, request.storage),
+        })));
+        let readings = await readCandidates();
+        let eligible = readings.filter(({ resources, diskGb }) => this.availableResourceUnits(resources, memoryMb, diskGb, cpuCores) > 0);
+        if (eligible.length === 0 && request.purgeIfFull) {
+            // Reclaim only permitted, healthy hosts on which the requested size can
+            // physically fit. Unknown/oversized requests never trigger cleanup.
+            const reclaimableHosts = readings.filter(({ resources, diskGb }) => resources.status === "online"
+                && resources.totalMemoryMb >= memoryMb && resources.totalDiskGb >= diskGb
+                && Number.isSafeInteger(cpuCores) && cpuCores > 0 && resources.cpuTotalCores >= cpuCores);
+            for (const { host } of reclaimableHosts) {
+                await this.purgeSlotsInternal({ host: host.hostId, destroyVms: true, includeOrphans: true, dryRun: false });
+                readings = await readCandidates();
+                eligible = readings.filter(({ resources, diskGb }) => this.availableResourceUnits(resources, memoryMb, diskGb, cpuCores) > 0);
+                if (eligible.length > 0)
+                    break;
             }
-            targetSlot = availableSlot;
         }
-        else {
-            // Homogeneous-fleet auto-placement. Every eligible host is a
-            // peer at the request boundary; production uses system randomness,
-            // while tests may supply an explicit seed for reproducible placement.
-            // Filter candidate hosts based on hypervisor preference (excluding ESXi unless allowEsxi)
-            const candidateHostConfigs = Array.from(this.hosts.values()).filter((h) => {
-                const pureSlots = calculatePureCapacity({ ...h, allowEsxiSlots: allowEsxi });
-                if (h.hypervisorType === "esxi" && !allowEsxi)
-                    return false;
-                if (pureSlots === 0 && (!allowEsxi || h.hypervisorType !== "esxi"))
-                    return false;
-                if (hypervisorTypePref === "proxmox" && h.hypervisorType !== "proxmox")
-                    return false;
-                if (hypervisorTypePref === "esxi" && h.hypervisorType !== "esxi")
-                    return false;
-                return true;
-            });
-            // Evaluate available slots and datastore health per host
-            const hostStats = candidateHostConfigs.map((h) => {
-                const hostSlots = Array.from(this.slots.values()).filter((s) => s.hostId === h.hostId);
-                const availableSlots = hostSlots.filter((s) => s.status === "AVAILABLE").length;
-                const freeDiskGb = h.freeDiskGb ?? 100;
-                const datastoreOk = h.hypervisorType !== "esxi" || freeDiskGb >= 10;
-                return { host: h, availableSlots, hostSlots, datastoreOk };
-            });
-            let totalAvailable = hostStats.reduce((sum, h) => sum + (h.datastoreOk ? h.availableSlots : 0), 0);
-            if (totalAvailable <= 0 && request.purgeIfFull) {
-                const purgeRes = await this.purgeSlotsInternal({
-                    destroyVms: true,
-                    includeOrphans: true,
-                    dryRun: false
-                });
-                if (purgeRes.purgedSlotsCount > 0 || purgeRes.destroyedVmsCount > 0) {
-                    for (const h of hostStats) {
-                        const hSlots = Array.from(this.slots.values()).filter((s) => s.hostId === h.host.hostId);
-                        h.availableSlots = hSlots.filter((s) => s.status === "AVAILABLE").length;
-                        h.hostSlots = hSlots;
-                    }
-                    totalAvailable = hostStats.reduce((sum, h) => sum + (h.datastoreOk ? h.availableSlots : 0), 0);
+        if (eligible.length === 0) {
+            const allocated = Array.from(this.slots.values()).filter((slot) => candidates.some((host) => host.hostId === slot.hostId) && slot.status !== "AVAILABLE").length;
+            if (requestedHost && requestedHost !== "auto") {
+                const resources = readings[0]?.resources;
+                if (resources?.status === "online" && resources.freeDiskGb < diskGb) {
+                    throw new DatastoreCapacityExceededError(requestedHost, diskGb, resources.freeDiskGb);
                 }
+                throw new CapacityExceededError(`Host '${requestedHost}' lacks verified free resources for ${memoryMb} MB RAM and ${diskGb} GB disk (capacity ${resources?.status ?? "unknown"}).`, requestedHost, allocated, allocated);
             }
-            if (totalAvailable <= 0) {
-                if (hypervisorTypePref === "proxmox") {
-                    throw new CapacityExceededError("All Proxmox cluster slots are currently allocated (2/2 on proxmox-lab, 4/4 on proxmox-mini).", "proxmox-cluster", 6, 6);
-                }
-                throw new GlobalCapacityExceededError("All 6 cluster slots are currently allocated (2/2 on proxmox-lab, 4/4 on proxmox-mini).", 6, 6);
-            }
-            const validCandidates = hostStats
-                .filter((h) => h.datastoreOk && h.availableSlots > 0)
-                .sort((a, b) => a.host.hostId.localeCompare(b.host.hostId));
-            const candidateIndex = request.placementSeed
-                ? createHash("sha256")
-                    .update(request.placementSeed)
-                    .digest()
-                    .readUInt32BE(0) % validCandidates.length
-                : randomInt(validCandidates.length);
-            const winningHostStat = validCandidates[candidateIndex];
-            if (!winningHostStat) {
-                throw new GlobalCapacityExceededError("All 6 cluster slots are currently allocated (2/2 on proxmox-lab, 4/4 on proxmox-mini).", 6, 6);
-            }
-            const availableSlotsOnWinner = winningHostStat.hostSlots
-                .filter((s) => s.status === "AVAILABLE")
-                .sort((a, b) => a.slotIndex - b.slotIndex);
-            targetSlot = availableSlotsOnWinner[0];
-        }
-        if (!targetSlot) {
-            throw new GlobalCapacityExceededError("All 6 cluster slots are currently allocated (2/2 on proxmox-lab, 4/4 on proxmox-mini).", 6, 6);
+            throw new GlobalCapacityExceededError(`No eligible host has verified free resources for ${memoryMb} MB RAM and ${diskGb} GB disk.`, allocated, allocated);
         }
+        eligible.sort((a, b) => a.host.hostId.localeCompare(b.host.hostId));
+        const preferredIndex = request.preferredHost ? eligible.findIndex(({ host }) => host.hostId === this.normalizeHostId(request.preferredHost)) : -1;
+        const index = preferredIndex >= 0 ? preferredIndex : request.placementSeed
+            ? createHash("sha256").update(request.placementSeed).digest().readUInt32BE(0) % eligible.length
+            : randomInt(eligible.length);
+        const targetSlot = this.createAvailableSlot(eligible[index].host);
+        targetSlot.memoryMb = memoryMb;
+        targetSlot.allocatedMemoryMb = memoryMb;
+        targetSlot.allocatedMemoryBytes = memoryMb * 1024 * 1024;
+        targetSlot.allocatedDiskGb = eligible[index].diskGb;
         // Assign claim details
         const claimId = `claim-${randomUUID().substring(0, 8)}`;
         const now = new Date();
@@ -549,6 +545,7 @@ export class SlotManager {
             memoryMb: targetSlot.memoryMb,
             allocatedMemoryMb: targetSlot.memoryMb,
             allocatedMemoryBytes: targetSlot.memoryMb * 1024 * 1024,
+            allocatedDiskGb: targetSlot.allocatedDiskGb,
             tag: targetSlot.tag,
             label: targetSlot.label || undefined,
             workloadType: targetSlot.workloadType || undefined,
@@ -840,6 +837,23 @@ export class SlotManager {
     async listSlots(options = {}) {
         return this.mutex.runExclusive(async () => {
             this.sweepExpiredSlotsInternal();
+            // Available slot IDs are a compatibility projection of current resources,
+            // never a preallocated admission pool. Existing occupied leases are untouched.
+            for (const host of this.hosts.values()) {
+                const resources = await this.readHostResources(host);
+                const additional = host.hypervisorType === "esxi" && !this.allowEsxiSlots ? 0
+                    : this.availableResourceUnits(resources, host.slotSizeMb);
+                const available = Array.from(this.slots.values()).filter((slot) => slot.hostId === host.hostId && slot.status === "AVAILABLE");
+                for (const slot of available.slice(additional))
+                    this.slots.delete(slot.slotId);
+                for (let index = available.length; index < additional; index++)
+                    this.createAvailableSlot(host, false);
+                for (const slot of available.slice(0, additional)) {
+                    slot.memoryMb = host.slotSizeMb;
+                    slot.allocatedMemoryMb = host.slotSizeMb;
+                    slot.allocatedMemoryBytes = host.slotSizeMb * 1024 * 1024;
+                }
+            }
             const now = Date.now();
             const results = [];
             const filterHost = options.host || options.targetHost;
@@ -932,6 +946,9 @@ export class SlotManager {
      * List host capacities or global cluster summary.
      */
     async listHosts(hostId) {
+        return this.mutex.runExclusive(() => this.listHostsInternal(hostId));
+    }
+    async listHostsInternal(hostId) {
         this.sweepExpiredSlotsInternal();
         const normalizedHostId = hostId && hostId !== "all" ? this.normalizeHostId(hostId) : hostId;
         // If specific ESXi host requested and not registered, auto-register
@@ -955,10 +972,12 @@ export class SlotManager {
                 return { ...s, remainingTtlSeconds };
             })
                 .sort((a, b) => a.slotIndex - b.slotIndex);
-            const activeSlots = hostSlots.filter((s) => s.status === "CLAIMED" || s.status === "active");
+            const activeSlots = hostSlots.filter((s) => s.status !== "AVAILABLE");
             const allocatedSlots = activeSlots.length;
-            const hostMaxSlots = config.maxSlots ?? calculatePureCapacity(config);
-            const availableSlots = Math.max(0, hostMaxSlots - allocatedSlots);
+            const resources = await this.readHostResources(config);
+            const availableSlots = config.hypervisorType === "esxi" && !this.allowEsxiSlots ? 0
+                : this.availableResourceUnits(resources, config.slotSizeMb);
+            const hostMaxSlots = allocatedSlots + availableSlots;
             clusterMaxSlots += hostMaxSlots;
             clusterAllocatedSlots += allocatedSlots;
             clusterAvailableSlots += availableSlots;
@@ -966,15 +985,18 @@ export class SlotManager {
                 hostId: id,
                 name: config.name,
                 hypervisorType: config.hypervisorType,
-                totalMemoryMb: config.totalMemoryMb,
-                reservedHeadroomMb: config.reservedHeadroomMb,
+                totalMemoryMb: resources.totalMemoryMb,
+                reservedHeadroomMb: 0,
+                admissionBasis: "physical_resources",
+                operationalStatus: resources.status,
+                capacityObservedAt: resources.observedAt,
                 maxSlots: hostMaxSlots,
                 allocatedSlots,
                 availableSlots,
                 slotSizeMb: config.slotSizeMb,
-                freeDiskGb: config.freeDiskGb,
-                totalDiskGb: config.totalDiskGb,
-                datastoreFreeBytes: config.datastoreFreeBytes,
+                freeDiskGb: resources.freeDiskGb,
+                totalDiskGb: resources.totalDiskGb,
+                datastoreFreeBytes: resources.freeDiskGb * 1024 ** 3,
                 activeSlots
             };
         }
@@ -1345,23 +1367,6 @@ export class SlotManager {
             const targetHyp = params.hypervisorType && params.hypervisorType !== "all" && params.hypervisorType !== "any"
                 ? params.hypervisorType
                 : undefined;
-            // Sync with live capacity if hypervisorManager is present
-            if (this.hypervisorManager) {
-                try {
-                    const liveCaps = await this.hypervisorManager.listAllHostsCapacity();
-                    for (const cap of liveCaps) {
-                        const hid = this.normalizeHostId(cap.name);
-                        const cfg = this.hosts.get(hid);
-                        if (cfg) {
-                            cfg.totalMemoryMb = Math.round(cap.memoryTotalBytes / (1024 * 1024));
-                            cfg.freeDiskGb = Math.round(cap.storageFreeBytes / (1024 * 1024 * 1024));
-                        }
-                    }
-                }
-                catch {
-                    // fallback to registered configs
-                }
-            }
             // Gather candidate hosts
             const allCandidates = [];
             for (const [hid, hostConfig] of this.hosts.entries()) {
@@ -1373,15 +1378,17 @@ export class SlotManager {
                     continue;
                 if (params.excludeHosts && params.excludeHosts.some((ex) => this.normalizeHostId(ex) === hid))
                     continue;
-                if (params.minFreeDiskGb && (hostConfig.freeDiskGb ?? 0) < params.minFreeDiskGb)
+                const resources = await this.readHostResources(hostConfig, params.storage);
+                if (params.minFreeDiskGb && resources.freeDiskGb < params.minFreeDiskGb)
                     continue;
                 const hostSlots = Array.from(this.slots.values()).filter((s) => s.hostId === hid);
-                const availCount = hostSlots.filter((s) => s.status === "AVAILABLE").length;
-                const pureCapacity = calculatePureCapacity({ ...hostConfig, allowEsxiSlots: allowEsxi });
-                const freeDisk = hostConfig.freeDiskGb ?? 100;
-                const totalMem = hostConfig.totalMemoryMb;
-                const reserved = hostConfig.reservedHeadroomMb || 0;
-                const freeMem = Math.max(0, totalMem - reserved - (hostSlots.length - availCount) * (hostConfig.slotSizeMb || 8192));
+                const memoryMb = params.requiredMemoryGb !== undefined ? params.requiredMemoryGb * 1024 : hostConfig.slotSizeMb;
+                const diskGb = params.diskGb ?? params.minFreeDiskGb ?? 10;
+                const availCount = this.availableResourceUnits(resources, memoryMb, diskGb, params.cpuCores);
+                const pureCapacity = hostSlots.filter((s) => s.status !== "AVAILABLE").length + availCount;
+                const freeDisk = resources.freeDiskGb;
+                const totalMem = resources.totalMemoryMb;
+                const freeMem = resources.freeMemoryMb;
                 // Host tiering: proxmox-mini (Tier 1 Primary), proxmox-lab (Tier 2 Secondary), ESXi (Tier 3 Fallback)
                 let tier = "secondary";
                 let tierBoost = 10000;
@@ -1407,15 +1414,17 @@ export class SlotManager {
                     hostId: hid,
                     name: hostConfig.name,
                     hypervisorType: hostConfig.hypervisorType || (hid.startsWith("esxi") ? "esxi" : "proxmox"),
-                    status: "online",
+                    status: resources.status === "online" ? "online" : "offline",
                     tier,
                     availableSlots: availCount,
                     totalPureSlots: pureCapacity,
                     freeMemoryMb: freeMem,
                     totalMemoryMb: totalMem,
                     freeDiskGb: freeDisk,
+                    totalDiskGb: resources.totalDiskGb,
+                    cpuTotalCores: resources.cpuTotalCores,
                     cpuUsedPercent: 0,
-                    runningVms: hostSlots.length - availCount,
+                    runningVms: hostSlots.filter((slot) => slot.status !== "AVAILABLE").length,
                     score,
                     recommendationReason
                 });
@@ -1479,6 +1488,10 @@ export class SlotManager {
                         branch: params.branch,
                         host: winningCandidate.hostId,
                         durationMinutes: params.durationMinutes,
+                        slotSizeMb: params.requiredMemoryGb !== undefined ? params.requiredMemoryGb * 1024 : undefined,
+                        diskGb: params.diskGb ?? params.minFreeDiskGb,
+                        cpuCores: params.cpuCores,
+                        storage: params.storage,
                         allowEsxiSlots: allowEsxi,
                         purpose: `Auto-claimed via find_slot on ${winningCandidate.hostId}`
                     });
@@ -1588,6 +1601,10 @@ export class SlotManager {
                         branch: params.branch,
                         host: targetHost || "auto",
                         durationMinutes: params.durationMinutes,
+                        slotSizeMb: params.requiredMemoryGb !== undefined ? params.requiredMemoryGb * 1024 : undefined,
+                        diskGb: params.diskGb ?? params.minFreeDiskGb,
+                        cpuCores: params.cpuCores,
+                        storage: params.storage,
                         allowEsxiSlots: allowEsxi,
                         purpose: `Auto-reclaimed and claimed via find_slot`
                     });