@calltelemetry/ct-lab-mcp 0.1.2 → 0.1.3

package/dist/src/slot/manager.js

@@ -1,11 +1,14 @@
 /**
  * Global Slot Allocation & Capacity Partitioning Engine
  * Manages 8GB appliance slots across Proxmox VE and VMware ESXi hosts with hard partition limits,
- * atomic concurrency locking (AsyncMutex), TTL lease management, and candidate slot ranking.
+ * atomic concurrency locking (AsyncMutex), TTL lease management, candidate slot ranking,
+ * structured metadata labeling/indexing, and automated expired slot purge & reclamation.
  */
 import { randomUUID } from "node:crypto";
 import { CapacityExceededError, GlobalCapacityExceededError, SlotNotFoundError, LeaseCeilingExceededError, InvalidSlotOperationError, DatastoreCapacityExceededError } from "./types.js";
 import { AsyncMutex } from "../utils/mutex.js";
+import { defaultSafetyGuardrailEngine } from "../guardrails/safety.js";
+import { telemetry } from "../telemetry/index.js";
 export * from "./types.js";
 const DEFAULT_HOST_CONFIGS = [
     {
@@ -49,9 +52,15 @@ export class SlotManager {
     mutex = new AsyncMutex();
     defaultDurationMinutes;
     proxmoxManager;
+    hypervisorManager;
+    guardrailEngine;
+    telemetry;
     constructor(options = {}) {
         this.defaultDurationMinutes = options.defaultDurationMinutes ?? 60;
         this.proxmoxManager = options.proxmoxManager;
+        this.hypervisorManager = options.hypervisorManager;
+        this.guardrailEngine = options.guardrailEngine || defaultSafetyGuardrailEngine;
+        this.telemetry = options.telemetryRegistry || telemetry;
         const hostConfigs = options.hosts && options.hosts.length > 0
             ? options.hosts
             : [...DEFAULT_HOST_CONFIGS];
@@ -62,6 +71,18 @@ export class SlotManager {
             this.registerHost(host);
         }
     }
+    /**
+     * Set or update hypervisor manager reference.
+     */
+    setHypervisorManager(hypervisorManager) {
+        this.hypervisorManager = hypervisorManager;
+    }
+    /**
+     * Set or update safety guardrail engine reference.
+     */
+    setGuardrailEngine(guardrailEngine) {
+        this.guardrailEngine = guardrailEngine;
+    }
     /**
      * Register a host and initialize its slot definitions.
      */
@@ -93,6 +114,11 @@ export class SlotManager {
                     ttlMinutes: null,
                     ttlSeconds: null,
                     tag: null,
+                    label: null,
+                    workloadType: null,
+                    targetVersion: null,
+                    branch: null,
+                    customTags: [],
                     requester: null,
                     linearIssue: null,
                     sessionId: null,
@@ -112,6 +138,19 @@ export class SlotManager {
             return "proxmox-mini";
         return hostId;
     }
+    /**
+     * Normalizes tag inputs into array of strings.
+     */
+    normalizeTagsArray(tags) {
+        if (!tags)
+            return [];
+        if (Array.isArray(tags))
+            return tags.map((t) => String(t).trim()).filter(Boolean);
+        if (typeof tags === "string") {
+            return tags.split(/[;, ]+/).map((t) => t.trim()).filter(Boolean);
+        }
+        return [];
+    }
     /**
      * Internal lazy expiration sweep (must be called inside mutex or synchronous method).
      */
@@ -121,6 +160,25 @@ export class SlotManager {
             if ((slot.status === "CLAIMED" || slot.status === "active") && slot.expiresAt) {
                 const expiresTime = new Date(slot.expiresAt).getTime();
                 if (expiresTime <= now) {
+                    // Emit expired telemetry event
+                    this.telemetry.emit({
+                        event: "slot.expired",
+                        actor: slot.requester || slot.sessionId || "system",
+                        status: "success",
+                        linearIssue: slot.linearIssue || undefined,
+                        slotId: slot.slotId,
+                        claimId: slot.claimId || undefined,
+                        vmId: slot.vmId || undefined,
+                        vmName: slot.vmName || undefined,
+                        hostId: slot.hostId,
+                        hypervisorType: slot.hypervisorType,
+                        metadata: {
+                            expiredAt: new Date(now).toISOString(),
+                            scheduledExpiresAt: slot.expiresAt,
+                            label: slot.label,
+                            workloadType: slot.workloadType
+                        }
+                    });
                     slot.status = "AVAILABLE";
                     slot.claimId = null;
                     slot.claimedAt = null;
@@ -129,6 +187,11 @@ export class SlotManager {
                     slot.ttlMinutes = null;
                     slot.ttlSeconds = null;
                     slot.tag = null;
+                    slot.label = null;
+                    slot.workloadType = null;
+                    slot.targetVersion = null;
+                    slot.branch = null;
+                    slot.customTags = [];
                     slot.requester = null;
                     slot.linearIssue = null;
                     slot.sessionId = null;
@@ -259,6 +322,20 @@ export class SlotManager {
             const now = new Date();
             const claimedAt = now.toISOString();
             const expiresAt = new Date(now.getTime() + durationMinutes * 60 * 1000).toISOString();
+            const linearIssue = request.linearIssue || (request.tag && request.tag.startsWith("CTUAT-") ? request.tag : null);
+            // Normalize custom tags
+            const customTags = [
+                ...this.normalizeTagsArray(request.customTags),
+                ...this.normalizeTagsArray(request.tags)
+            ];
+            // Deduplicate tags
+            const uniqueTags = Array.from(new Set(customTags));
+            // Auto-assign human readable label if not provided
+            const label = request.label || (linearIssue
+                ? `[${linearIssue}] ${request.workloadType || "workload"}: Slot ${targetSlot.slotIndex}`
+                : request.purpose
+                    ? `${request.purpose} (Slot ${targetSlot.slotIndex})`
+                    : `${request.tag || tagInput} Lease`);
             targetSlot.status = "CLAIMED";
             targetSlot.claimId = claimId;
             targetSlot.claimedAt = claimedAt;
@@ -267,11 +344,35 @@ export class SlotManager {
             targetSlot.ttlMinutes = durationMinutes;
             targetSlot.ttlSeconds = durationMinutes * 60;
             targetSlot.tag = (request.tag || tagInput).trim();
+            targetSlot.label = label;
+            targetSlot.workloadType = request.workloadType || null;
+            targetSlot.targetVersion = request.targetVersion || null;
+            targetSlot.branch = request.branch || null;
+            targetSlot.customTags = uniqueTags;
             targetSlot.requester = request.requester || request.tag || null;
-            targetSlot.linearIssue = request.linearIssue || (request.tag && request.tag.startsWith("CTUAT-") ? request.tag : null);
+            targetSlot.linearIssue = linearIssue;
             targetSlot.sessionId = request.sessionId || null;
             targetSlot.purpose = request.purpose || null;
             targetSlot.metadata = request.metadata || {};
+            // Emit audit telemetry
+            this.telemetry.emit({
+                event: "slot.claim",
+                actor: targetSlot.requester || targetSlot.sessionId || "unknown",
+                status: "success",
+                linearIssue: linearIssue || undefined,
+                slotId: targetSlot.slotId,
+                claimId,
+                hostId: targetSlot.hostId,
+                hypervisorType: targetSlot.hypervisorType,
+                metadata: {
+                    label: targetSlot.label,
+                    workloadType: targetSlot.workloadType,
+                    targetVersion: targetSlot.targetVersion,
+                    branch: targetSlot.branch,
+                    durationMinutes,
+                    expiresAt
+                }
+            });
             return {
                 claimId,
                 slotId: targetSlot.slotId,
@@ -283,6 +384,11 @@ export class SlotManager {
                 allocatedMemoryMb: targetSlot.memoryMb,
                 allocatedMemoryBytes: targetSlot.memoryMb * 1024 * 1024,
                 tag: targetSlot.tag,
+                label: targetSlot.label || undefined,
+                workloadType: targetSlot.workloadType || undefined,
+                targetVersion: targetSlot.targetVersion || undefined,
+                branch: targetSlot.branch || undefined,
+                customTags: targetSlot.customTags.length > 0 ? targetSlot.customTags : undefined,
                 requester: targetSlot.requester || undefined,
                 linearIssue: targetSlot.linearIssue || undefined,
                 claimedAt,
@@ -380,6 +486,23 @@ export class SlotManager {
                 if (destroyVm && slot.vmId !== null && slot.vmId !== undefined) {
                     destroyedVms.push(slot.vmId);
                 }
+                // Emit telemetry for released slot
+                this.telemetry.emit({
+                    event: "slot.release",
+                    actor: requester || sessionId || slot.requester || "unknown",
+                    status: "success",
+                    linearIssue: slot.linearIssue || undefined,
+                    slotId: slot.slotId,
+                    claimId: slot.claimId || undefined,
+                    vmId: slot.vmId || undefined,
+                    vmName: slot.vmName || undefined,
+                    hostId: slot.hostId,
+                    hypervisorType: slot.hypervisorType,
+                    metadata: {
+                        freedMemoryMb: slot.memoryMb,
+                        destroyVmRequested: Boolean(destroyVm)
+                    }
+                });
                 slot.status = "AVAILABLE";
                 slot.claimId = null;
                 slot.claimedAt = null;
@@ -388,6 +511,11 @@ export class SlotManager {
                 slot.ttlMinutes = null;
                 slot.ttlSeconds = null;
                 slot.tag = null;
+                slot.label = null;
+                slot.workloadType = null;
+                slot.targetVersion = null;
+                slot.branch = null;
+                slot.customTags = [];
                 slot.requester = null;
                 slot.linearIssue = null;
                 slot.sessionId = null;
@@ -438,6 +566,23 @@ export class SlotManager {
             slot.durationMinutes = totalDurationMinutes;
             slot.ttlMinutes = totalDurationMinutes;
             slot.ttlSeconds = totalDurationMinutes * 60;
+            // Emit telemetry for extension
+            this.telemetry.emit({
+                event: "slot.extend",
+                actor: sessionId || slot.requester || "unknown",
+                status: "success",
+                linearIssue: slot.linearIssue || undefined,
+                slotId: slot.slotId,
+                claimId,
+                hostId: slot.hostId,
+                hypervisorType: slot.hypervisorType,
+                metadata: {
+                    extendedByMinutes: additionalMinutes,
+                    previousExpiresAt,
+                    newExpiresAt,
+                    totalDurationMinutes
+                }
+            });
             return {
                 claimId,
                 slotId: slot.slotId,
@@ -451,7 +596,81 @@ export class SlotManager {
         });
     }
     /**
-     * List slots with optional filtering and computed remaining TTL.
+     * Update metadata, label, workload type, or tags on an active slot lease.
+     */
+    async updateSlotMetadata(options) {
+        return this.mutex.runExclusive(async () => {
+            this.sweepExpiredSlotsInternal();
+            const { claimId, slotId } = options;
+            if (!claimId && !slotId) {
+                throw new InvalidSlotOperationError("Must provide 'claimId' or 'slotId' to update slot metadata.");
+            }
+            const slot = Array.from(this.slots.values()).find((s) => (claimId && s.claimId === claimId) || (slotId && s.slotId === slotId));
+            if (!slot || (slot.status !== "CLAIMED" && slot.status !== "active")) {
+                throw new SlotNotFoundError(`Active slot not found matching ${claimId ? `claimId '${claimId}'` : `slotId '${slotId}'`}.`);
+            }
+            const updatedFields = [];
+            if (options.label !== undefined) {
+                slot.label = options.label;
+                updatedFields.push("label");
+            }
+            if (options.workloadType !== undefined) {
+                slot.workloadType = options.workloadType;
+                updatedFields.push("workloadType");
+            }
+            if (options.targetVersion !== undefined) {
+                slot.targetVersion = options.targetVersion;
+                updatedFields.push("targetVersion");
+            }
+            if (options.branch !== undefined) {
+                slot.branch = options.branch;
+                updatedFields.push("branch");
+            }
+            if (options.customTags !== undefined) {
+                slot.customTags = this.normalizeTagsArray(options.customTags);
+                updatedFields.push("customTags");
+            }
+            if (options.linearIssue !== undefined) {
+                slot.linearIssue = options.linearIssue;
+                updatedFields.push("linearIssue");
+            }
+            if (options.purpose !== undefined) {
+                slot.purpose = options.purpose;
+                updatedFields.push("purpose");
+            }
+            if (options.metadata !== undefined) {
+                slot.metadata = { ...(slot.metadata || {}), ...options.metadata };
+                updatedFields.push("metadata");
+            }
+            // Emit telemetry for metadata update
+            this.telemetry.emit({
+                event: "slot.update_metadata",
+                actor: slot.requester || slot.sessionId || "unknown",
+                status: "success",
+                linearIssue: slot.linearIssue || undefined,
+                slotId: slot.slotId,
+                claimId: slot.claimId || undefined,
+                hostId: slot.hostId,
+                hypervisorType: slot.hypervisorType,
+                metadata: {
+                    updatedFields,
+                    label: slot.label,
+                    workloadType: slot.workloadType,
+                    targetVersion: slot.targetVersion,
+                    branch: slot.branch,
+                    customTags: slot.customTags
+                }
+            });
+            return {
+                success: true,
+                slot: { ...slot },
+                updatedFields,
+                message: `Successfully updated ${updatedFields.length} metadata field(s) on slot ${slot.slotId}.`
+            };
+        });
+    }
+    /**
+     * List slots with comprehensive multi-field filtering and computed remaining TTL.
      */
     async listSlots(options = {}) {
         return this.mutex.runExclusive(async () => {
@@ -460,6 +679,10 @@ export class SlotManager {
             const results = [];
             const filterHost = options.host || options.targetHost;
             const normalizedFilterHost = filterHost ? this.normalizeHostId(filterHost) : undefined;
+            const parsedTags = [
+                ...this.normalizeTagsArray(options.tags),
+                ...this.normalizeTagsArray(options.customTags)
+            ];
             for (const slot of this.slots.values()) {
                 if (normalizedFilterHost && slot.hostId !== normalizedFilterHost)
                     continue;
@@ -477,6 +700,51 @@ export class SlotManager {
                     slot.hypervisorType !== options.hypervisorType) {
                     continue;
                 }
+                // Structured metadata filters
+                if (options.workloadType && slot.workloadType !== options.workloadType)
+                    continue;
+                if (options.targetVersion && slot.targetVersion !== options.targetVersion)
+                    continue;
+                if (options.branch && slot.branch !== options.branch)
+                    continue;
+                if (options.label && (!slot.label || !slot.label.toLowerCase().includes(options.label.toLowerCase()))) {
+                    continue;
+                }
+                // Custom tags matching (must match at least one if specified)
+                if (parsedTags.length > 0) {
+                    const slotAllTags = [
+                        ...(slot.customTags || []),
+                        slot.tag,
+                        slot.linearIssue
+                    ].filter(Boolean).map((t) => String(t).toLowerCase());
+                    const matchesTag = parsedTags.some((pt) => slotAllTags.some((st) => st.includes(pt.toLowerCase())));
+                    if (!matchesTag)
+                        continue;
+                }
+                // Free-text filter search across all string metadata fields
+                if (options.filter) {
+                    const q = options.filter.toLowerCase().trim();
+                    const searchable = [
+                        slot.slotId,
+                        slot.hostId,
+                        slot.tag,
+                        slot.label,
+                        slot.workloadType,
+                        slot.targetVersion,
+                        slot.branch,
+                        slot.linearIssue,
+                        slot.purpose,
+                        slot.requester,
+                        slot.vmName,
+                        slot.vmId ? String(slot.vmId) : null,
+                        ...(slot.customTags || [])
+                    ]
+                        .filter(Boolean)
+                        .join(" ")
+                        .toLowerCase();
+                    if (!searchable.includes(q))
+                        continue;
+                }
                 let remainingTtlSeconds = null;
                 if ((slot.status === "CLAIMED" || slot.status === "active") && slot.expiresAt) {
                     const diffMs = new Date(slot.expiresAt).getTime() - now;
@@ -586,6 +854,302 @@ export class SlotManager {
             return this.sweepExpiredSlotsInternal();
         });
     }
+    /**
+     * Purge expired, threshold-exceeded, or orphaned slots and reclaim hypervisor VM capacity.
+     * Gated by SafetyGuardrailEngine non-bypassable protections.
+     */
+    async purgeSlots(options = {}) {
+        return this.mutex.runExclusive(async () => {
+            const now = Date.now();
+            const dryRun = options.dryRun ?? false;
+            const destroyVms = options.destroyVms ?? true;
+            const force = options.force ?? false;
+            const includeOrphans = options.includeOrphans ?? false;
+            const targetHost = options.host && options.host !== "all" ? this.normalizeHostId(options.host) : undefined;
+            const targetHypervisor = options.hypervisorType && options.hypervisorType !== "all" && options.hypervisorType !== "any"
+                ? options.hypervisorType
+                : undefined;
+            const matchingSlots = [];
+            const reasons = new Map();
+            for (const slot of this.slots.values()) {
+                if (slot.status !== "CLAIMED" && slot.status !== "active")
+                    continue;
+                if (targetHost && slot.hostId !== targetHost)
+                    continue;
+                if (targetHypervisor && slot.hypervisorType !== targetHypervisor)
+                    continue;
+                let shouldPurge = false;
+                let reason = "manual_purge";
+                const expiresTime = slot.expiresAt ? new Date(slot.expiresAt).getTime() : 0;
+                const claimedTime = slot.claimedAt ? new Date(slot.claimedAt).getTime() : 0;
+                const isExpired = expiresTime > 0 && expiresTime <= now;
+                if (options.linearIssue) {
+                    const matchesLinear = slot.linearIssue === options.linearIssue || slot.tag === options.linearIssue;
+                    if (matchesLinear) {
+                        shouldPurge = true;
+                        reason = isExpired ? "expired" : "linear_match";
+                    }
+                }
+                else if (options.olderThanMinutes !== undefined) {
+                    const ageMinutes = (now - claimedTime) / (60 * 1000);
+                    if (ageMinutes >= options.olderThanMinutes || isExpired) {
+                        shouldPurge = true;
+                        reason = isExpired ? "expired" : "older_than_threshold";
+                    }
+                }
+                else if (isExpired) {
+                    shouldPurge = true;
+                    reason = "expired";
+                }
+                else if (force) {
+                    shouldPurge = true;
+                    reason = "forced";
+                }
+                if (shouldPurge) {
+                    matchingSlots.push(slot);
+                    reasons.set(slot.slotId, reason);
+                }
+            }
+            const purgedSlots = [];
+            const destroyedVms = [];
+            let skippedProtectedCount = 0;
+            let reclaimedMemoryMb = 0;
+            for (const slot of matchingSlots) {
+                const reason = reasons.get(slot.slotId) || "manual_purge";
+                purgedSlots.push({
+                    slotId: slot.slotId,
+                    hostId: slot.hostId,
+                    claimId: slot.claimId,
+                    claimedAt: slot.claimedAt,
+                    expiresAt: slot.expiresAt,
+                    linearIssue: slot.linearIssue,
+                    label: slot.label,
+                    workloadType: slot.workloadType,
+                    vmId: slot.vmId,
+                    vmName: slot.vmName,
+                    reason
+                });
+                reclaimedMemoryMb += slot.memoryMb;
+                // Process attached VM cleanup if present
+                if (slot.vmId !== null && slot.vmId !== undefined) {
+                    const vmTarget = {
+                        vmid: slot.vmId,
+                        name: slot.vmName || undefined,
+                        isProtected: false
+                    };
+                    // Guardrail safety check
+                    const protCheck = this.guardrailEngine.isProtected(vmTarget);
+                    if (protCheck.protected) {
+                        skippedProtectedCount++;
+                        destroyedVms.push({
+                            vmId: slot.vmId,
+                            vmName: slot.vmName || undefined,
+                            hostId: slot.hostId,
+                            hypervisorType: slot.hypervisorType,
+                            status: "skipped_protected",
+                            reason: `Protected infrastructure preserved: ${protCheck.reason}`
+                        });
+                        this.telemetry.emit({
+                            event: "vm.guardrail_blocked",
+                            actor: slot.requester || "system",
+                            status: "blocked",
+                            linearIssue: slot.linearIssue || undefined,
+                            vmId: slot.vmId,
+                            vmName: slot.vmName || undefined,
+                            hostId: slot.hostId,
+                            hypervisorType: slot.hypervisorType,
+                            error: `Guardrail blocked purge destruction: ${protCheck.reason}`
+                        });
+                    }
+                    else {
+                        if (dryRun) {
+                            destroyedVms.push({
+                                vmId: slot.vmId,
+                                vmName: slot.vmName || undefined,
+                                hostId: slot.hostId,
+                                hypervisorType: slot.hypervisorType,
+                                status: "dry_run",
+                                reason: `Would be destroyed during purge (${reason})`
+                            });
+                        }
+                        else if (destroyVms && this.hypervisorManager) {
+                            try {
+                                await this.hypervisorManager.vmAction({
+                                    vmIdOrName: String(slot.vmId),
+                                    targetHost: slot.hostId,
+                                    action: "destroy",
+                                    force: true
+                                });
+                                destroyedVms.push({
+                                    vmId: slot.vmId,
+                                    vmName: slot.vmName || undefined,
+                                    hostId: slot.hostId,
+                                    hypervisorType: slot.hypervisorType,
+                                    status: "destroyed",
+                                    reason: `Purged and destroyed attached VM (${reason})`
+                                });
+                                this.telemetry.emit({
+                                    event: "vm.purged",
+                                    actor: slot.requester || "system",
+                                    status: "success",
+                                    linearIssue: slot.linearIssue || undefined,
+                                    vmId: slot.vmId,
+                                    vmName: slot.vmName || undefined,
+                                    hostId: slot.hostId,
+                                    hypervisorType: slot.hypervisorType,
+                                    metadata: { slotId: slot.slotId, reason }
+                                });
+                            }
+                            catch (err) {
+                                destroyedVms.push({
+                                    vmId: slot.vmId,
+                                    vmName: slot.vmName || undefined,
+                                    hostId: slot.hostId,
+                                    hypervisorType: slot.hypervisorType,
+                                    status: "failed",
+                                    error: err instanceof Error ? err.message : String(err)
+                                });
+                            }
+                        }
+                    }
+                }
+                // If not a dry run, reset slot state
+                if (!dryRun) {
+                    this.telemetry.emit({
+                        event: "slot.purge",
+                        actor: slot.requester || "system",
+                        status: "success",
+                        linearIssue: slot.linearIssue || undefined,
+                        slotId: slot.slotId,
+                        claimId: slot.claimId || undefined,
+                        vmId: slot.vmId || undefined,
+                        vmName: slot.vmName || undefined,
+                        hostId: slot.hostId,
+                        hypervisorType: slot.hypervisorType,
+                        metadata: {
+                            reason,
+                            freedMemoryMb: slot.memoryMb
+                        }
+                    });
+                    slot.status = "AVAILABLE";
+                    slot.claimId = null;
+                    slot.claimedAt = null;
+                    slot.expiresAt = null;
+                    slot.durationMinutes = null;
+                    slot.ttlMinutes = null;
+                    slot.ttlSeconds = null;
+                    slot.tag = null;
+                    slot.label = null;
+                    slot.workloadType = null;
+                    slot.targetVersion = null;
+                    slot.branch = null;
+                    slot.customTags = [];
+                    slot.requester = null;
+                    slot.linearIssue = null;
+                    slot.sessionId = null;
+                    slot.purpose = null;
+                    slot.vmId = null;
+                    slot.vmName = null;
+                    slot.metadata = {};
+                }
+            }
+            // Check orphan VMs if requested
+            if (includeOrphans && this.hypervisorManager) {
+                try {
+                    const allVms = await this.hypervisorManager.listUnifiedInventory({
+                        includeTemplates: false,
+                        host: targetHost,
+                        hypervisor: targetHypervisor
+                    });
+                    const activeVmIds = new Set(Array.from(this.slots.values())
+                        .map((s) => s.vmId)
+                        .filter((id) => id !== null && id !== undefined)
+                        .map((id) => String(id)));
+                    for (const vm of allVms) {
+                        // Check if VM is an untracked disposable VM without active lease
+                        if (!vm.isTemplate && !vm.isProtected && !activeVmIds.has(String(vm.id))) {
+                            const protCheck = this.guardrailEngine.isProtected({
+                                vmid: vm.id,
+                                name: vm.name,
+                                isProtected: vm.isProtected,
+                                tags: vm.tags
+                            });
+                            if (protCheck.protected) {
+                                skippedProtectedCount++;
+                                destroyedVms.push({
+                                    vmId: vm.id,
+                                    vmName: vm.name,
+                                    hostId: vm.hostName,
+                                    hypervisorType: vm.hypervisor,
+                                    status: "skipped_protected",
+                                    reason: `Protected orphan preserved: ${protCheck.reason}`
+                                });
+                            }
+                            else {
+                                if (dryRun) {
+                                    destroyedVms.push({
+                                        vmId: vm.id,
+                                        vmName: vm.name,
+                                        hostId: vm.hostName,
+                                        hypervisorType: vm.hypervisor,
+                                        status: "dry_run",
+                                        reason: "Orphaned disposable VM with no active slot lease"
+                                    });
+                                }
+                                else if (destroyVms) {
+                                    try {
+                                        await this.hypervisorManager.vmAction({
+                                            vmIdOrName: String(vm.id),
+                                            targetHost: vm.hostName,
+                                            action: "destroy",
+                                            force: true
+                                        });
+                                        destroyedVms.push({
+                                            vmId: vm.id,
+                                            vmName: vm.name,
+                                            hostId: vm.hostName,
+                                            hypervisorType: vm.hypervisor,
+                                            status: "destroyed",
+                                            reason: "Destroyed orphaned disposable VM with no active slot lease"
+                                        });
+                                    }
+                                    catch (orphanErr) {
+                                        destroyedVms.push({
+                                            vmId: vm.id,
+                                            vmName: vm.name,
+                                            hostId: vm.hostName,
+                                            hypervisorType: vm.hypervisor,
+                                            status: "failed",
+                                            error: orphanErr instanceof Error ? orphanErr.message : String(orphanErr)
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (invErr) {
+                    console.error("[purgeSlots] Orphan inventory inspection error:", invErr);
+                }
+            }
+            const destroyedCount = destroyedVms.filter((v) => v.status === "destroyed").length;
+            const reclaimedMemoryBytes = reclaimedMemoryMb * 1024 * 1024;
+            const prefix = dryRun ? "[DRY RUN] " : "";
+            const message = `${prefix}Purged ${purgedSlots.length} slot lease(s), reclaimed ${reclaimedMemoryMb / 1024} GB RAM, processed ${destroyedVms.length} VM(s) (${destroyedCount} destroyed, ${skippedProtectedCount} protected skipped).`;
+            return {
+                purgedSlotsCount: purgedSlots.length,
+                purgedSlots,
+                destroyedVmsCount: destroyedCount,
+                destroyedVms,
+                skippedProtectedVmsCount: skippedProtectedCount,
+                reclaimedMemoryBytes,
+                reclaimedMemoryMb,
+                dryRun,
+                timestamp: new Date(now).toISOString(),
+                message
+            };
+        });
+    }
     /**
      * Attach a created VMID or VM name to a claimed slot.
      */
@@ -636,6 +1200,11 @@ export class SlotManager {
                 slot.ttlMinutes = null;
                 slot.ttlSeconds = null;
                 slot.tag = null;
+                slot.label = null;
+                slot.workloadType = null;
+                slot.targetVersion = null;
+                slot.branch = null;
+                slot.customTags = [];
                 slot.requester = null;
                 slot.linearIssue = null;
                 slot.sessionId = null;