fix

.agent/memory/session.json

@@ -1,7 +1,7 @@
 {
   "version": "1.0.0",
-  "session_id": "9c33f220",
-  "started_at": "2026-04-09T19:43:54.970676+05:30",
+  "session_id": "e37e0066",
+  "started_at": "2026-04-09T20:26:42.840184+05:30",
   "workspace": "D:\\Code\\codeverse",
   "active_task_id": null,
   "active_agent": null,

app/api/system/vitals/route.ts

@@ -1,37 +1,41 @@
 import { NextResponse } from 'next/server';
 import os from 'os';
+import type { SystemVitals, SystemVitalsResponse } from '@/lib/system/vitals';
 
 /**
  * Infrastructure Health & Vitals API.
  * Provides real-time metrics for Hugging Face Spaces monitoring.
  */
+export const dynamic = 'force-dynamic';
+
 export async function GET() {
     const memory = process.memoryUsage();
-    const systemMemory = {
+    const systemMemory: SystemVitals['systemMemory'] = {
         free: os.freemem(),
         total: os.totalmem(),
     };
 
     const uptime = process.uptime();
-    const load = os.loadavg();
+    const load = os.loadavg() as SystemVitals['loadAvg'];
+
+    const vitals: SystemVitals = {
+        rss: memory.rss,
+        heapUsed: memory.heapUsed,
+        heapTotal: memory.heapTotal,
+        loadAvg: load,
+        uptime,
+        systemMemory,
+        nodeVersion: process.version,
+    };
 
-    return NextResponse.json({
+    const response: SystemVitalsResponse = {
         success: true,
-        vitals: {
-            process: {
-                rss: (memory.rss / 1024 / 1024).toFixed(2), // MB
-                heapUsed: (memory.heapUsed / 1024 / 1024).toFixed(2), // MB
-                heapTotal: (memory.heapTotal / 1024 / 1024).toFixed(2), // MB
-            },
-            system: {
-                freeMB: (systemMemory.free / 1024 / 1024).toFixed(0),
-                totalMB: (systemMemory.total / 1024 / 1024).toFixed(0),
-                loadAverage: load[0].toFixed(2),
-            },
-            status: {
-                uptime: `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m`,
-                nodeVersion: process.version,
-            }
-        }
+        vitals,
+    };
+
+    return NextResponse.json(response, {
+        headers: {
+            'Cache-Control': 'no-store',
+        },
     });
 }

components/DashboardVitals.tsx

@@ -3,14 +3,9 @@
 import React, { useEffect, useState } from 'react';
 import { motion, AnimatePresence } from 'framer-motion';
 import { Activity, Cpu, HardDrive, Zap } from 'lucide-react';
+import type { SystemVitalsResponse } from '@/lib/system/vitals';
 
-interface VitalsData {
-    rss: number;
-    heapUsed: number;
-    heapTotal: number;
-    loadAvg: number[];
-    uptime: number;
-}
+type VitalsData = SystemVitalsResponse['vitals'];
 
 /**
  * Premium Infrastructure Vitals Monitor (2026 Studio Edition)
@@ -21,21 +16,34 @@ export const DashboardVitals: React.FC = () => {
     const [error, setError] = useState<string | null>(null);
 
     useEffect(() => {
+        let isDisposed = false;
+
         const fetchVitals = async () => {
             try {
-                const res = await fetch('/api/stats');
-                if (res.ok) {
-                    const data = await res.json();
-                    setVitals(data);
+                const res = await fetch('/api/system/vitals', { cache: 'no-store' });
+                if (!res.ok) {
+                    throw new Error(`Vitals request failed with status ${res.status}`);
+                }
+
+                const data = await res.json() as SystemVitalsResponse;
+                if (!isDisposed) {
+                    setVitals(data.vitals);
+                    setError(null);
+                }
+            } catch (error) {
+                if (!isDisposed) {
+                    setError(error instanceof Error ? error.message : 'Vitals Link Offline');
                 }
-            } catch {
-                setError("Vitals Link Offline");
             }
         };
 
-        fetchVitals();
+        void fetchVitals();
         const interval = setInterval(fetchVitals, 5000);
-        return () => clearInterval(interval);
+
+        return () => {
+            isDisposed = true;
+            clearInterval(interval);
+        };
     }, []);
 
     const formatBytes = (bytes: number) => {

dist/lib/docker/manager.js

@@ -147,21 +147,63 @@ function findAvailablePort() {
     }
     return port;
 }
+function resolveExecutableOnPath(candidates) {
+    const locatorCommand = process.platform === 'win32' ? 'where' : 'which';
+    for (const candidate of candidates) {
+        try {
+            const output = (0, child_process_1.execFileSync)(locatorCommand, [candidate], {
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            const resolvedPath = output
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .find(Boolean);
+            if (resolvedPath) {
+                return resolvedPath;
+            }
+        }
+        catch (_a) {
+            // Fall through to the next candidate.
+        }
+    }
+    return null;
+}
+function quoteWindowsCmdArg(value) {
+    if (value.length === 0) {
+        return '""';
+    }
+    if (!/[ \t"]/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/"/g, '""')}"`;
+}
 function resolveCodeServerLaunch() {
     const overrideBinary = process.env.CODE_SERVER_BIN;
     if (overrideBinary) {
-        return { command: overrideBinary, args: [], label: overrideBinary };
+        const useShell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(overrideBinary);
+        return { command: overrideBinary, args: [], label: overrideBinary, usesNpx: false, useShell };
     }
     if (process.platform === 'win32') {
-        try {
-            (0, child_process_1.execSync)('where code-server.cmd', { stdio: 'ignore' });
-            return { command: 'code-server.cmd', args: [], label: 'code-server' };
+        const codeServerBinary = resolveExecutableOnPath(['code-server.exe', 'code-server']);
+        if (codeServerBinary) {
+            return { command: codeServerBinary, args: [], label: 'code-server', usesNpx: false, useShell: false };
         }
-        catch (_a) {
-            return { command: 'npx.cmd', args: ['--yes', 'code-server'], label: 'npx code-server' };
+        const npxCliPath = path_1.default.join(path_1.default.dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npx-cli.js');
+        if (fs_1.default.existsSync(npxCliPath)) {
+            return { command: process.execPath, args: [npxCliPath, '--yes', 'code-server'], label: 'node npx-cli.js code-server', usesNpx: true, useShell: false };
         }
+        throw new Error('CODE_SERVER_BIN_NOT_FOUND');
     }
-    return { command: 'code-server', args: [], label: 'code-server' };
+    const codeServerBinary = resolveExecutableOnPath(['code-server']);
+    if (codeServerBinary) {
+        return { command: codeServerBinary, args: [], label: 'code-server', usesNpx: false, useShell: false };
+    }
+    const npxBinary = resolveExecutableOnPath(['npx']);
+    if (npxBinary) {
+        return { command: npxBinary, args: ['--yes', 'code-server'], label: 'npx code-server', usesNpx: true, useShell: false };
+    }
+    throw new Error('CODE_SERVER_BIN_NOT_FOUND');
 }
 /**
  * Checks if Docker is available in the current environment.
@@ -236,6 +278,7 @@ async function prewarmWorkspace(config) {
  * INTERNAL: Core provisioning logic with IDX support and auto-provisioning baseline.
  */
 async function performProvisioning(config) {
+    var _a, _b;
     const log = (msg) => {
         if (config.onLog)
             config.onLog(`[IDX:ENGINE] ${msg}`);
@@ -277,6 +320,14 @@ async function performProvisioning(config) {
         const codeServerLaunch = resolveCodeServerLaunch();
         const shellCommand = codeServerLaunch.command;
         const args = codeServerLaunch.args;
+        const spawnCwd = (() => {
+            try {
+                return fs_1.default.realpathSync(workspacePath);
+            }
+            catch (_a) {
+                return workspacePath;
+            }
+        })();
         const baseArgs = [
             '--auth', 'none',
             '--bind-addr', `127.0.0.1:${port}`,
@@ -293,11 +344,24 @@ async function performProvisioning(config) {
         };
         delete spawnEnv.PORT;
         delete spawnEnv.SERVER_PORT;
-        const child = (0, child_process_1.spawn)(shellCommand, [...args, ...baseArgs], {
-            env: spawnEnv,
-            cwd: workspacePath,
-            shell: false
-        });
+        const launchArgs = [...args, ...baseArgs];
+        const launchCommand = codeServerLaunch.useShell ? (process.env.ComSpec || 'cmd.exe') : shellCommand;
+        const launchCommandArgs = codeServerLaunch.useShell
+            ? ['/d', '/s', '/c', [quoteWindowsCmdArg(shellCommand), ...launchArgs.map(quoteWindowsCmdArg)].join(' ')]
+            : launchArgs;
+        log(`IDE launch prepared. Binary: ${shellCommand} | cwd: ${spawnCwd} | target: ${workspacePath}`);
+        let child;
+        try {
+            child = (0, child_process_1.spawn)(launchCommand, launchCommandArgs, {
+                env: spawnEnv,
+                cwd: spawnCwd,
+                shell: false
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`IDE_SPAWN_CONFIGURATION_REJECTED: ${errorMessage}`);
+        }
         log(`Spawning VS Code Orchestrator via ${codeServerLaunch.label} (PID: ${child.pid})...`);
         let childExited = false;
         let childFailureReason = null;
@@ -305,14 +369,14 @@ async function performProvisioning(config) {
             childFailureReason = `IDE_BINARY_FAILURE: ${err.message}`;
             log(`[FATAL] IDE binary failure: ${err.message}`);
         });
-        child.stdout.on('data', (data) => {
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
             const out = data.toString().trim();
             if (out.includes('listening on'))
                 log(`[IDX:UP] ${out}`);
             else if (out.length > 0)
                 log(`[IDE:CORE] ${out}`);
         });
-        child.stderr.on('data', (data) => {
+        (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
             const err = data.toString().trim();
             if (err.length > 0)
                 log(`[IDE:ERR] ${err}`);
@@ -332,7 +396,7 @@ async function performProvisioning(config) {
         while (attempts < 60) {
             if (childExited) {
                 const rawFailureMessage = childFailureReason !== null && childFailureReason !== void 0 ? childFailureReason : 'IDE_PROCESS_EXITED_BEFORE_HANDSHAKE';
-                const failureMessage = shellCommand === 'npx'
+                const failureMessage = codeServerLaunch.usesNpx
                     ? `${rawFailureMessage}. code-server could not be bootstrapped via npx. Install code-server globally or set CODE_SERVER_BIN.`
                     : rawFailureMessage;
                 log(`[FATAL] IDE bootstrap aborted before handshake: ${failureMessage}`);
@@ -358,7 +422,7 @@ async function performProvisioning(config) {
                     return finalResult;
                 }
             }
-            catch (_a) {
+            catch (_c) {
                 if (attempts % 5 === 0)
                     log(`[INFO] Scanning for IDE heartbeat... (Attempt ${attempts}/60)`);
                 if (attempts === 15)
@@ -383,7 +447,7 @@ async function performProvisioning(config) {
         const error = e instanceof Error ? e.message : String(e);
         log(`[FATAL] Provisioning pipeline collapsed: ${error}`);
         exports.nativeProcesses.delete(config.id);
-        const errResult = { success: false, error: "PROVISIONING_FAILED" };
+        const errResult = { success: false, error: `PROVISIONING_FAILED: ${error}` };
         exports.provisioningBus.emit(`error:${config.id}`, errResult);
         return errResult;
     }

dist/lib/hf/storage.js

@@ -15,6 +15,18 @@ class HFStorage {
     static get isPersistenceRuntimeEnabled() {
         return Boolean(env_config_1.ENV_CONFIG.SPACE_ID && this.HF_TOKEN && this.HF_DATASET_ID && process.platform !== 'win32');
     }
+    static getPersistenceEntries() {
+        const home = process.env.HOME || '/home/node';
+        const relativeWorkspaceRoot = path_1.default.relative(home, this.WORKSPACE_ROOT).replace(/\\/g, '/');
+        const workspaceDatasetPath = relativeWorkspaceRoot.startsWith('..')
+            ? path_1.default.basename(this.WORKSPACE_ROOT)
+            : relativeWorkspaceRoot;
+        return [
+            { datasetPath: workspaceDatasetPath, localPath: this.WORKSPACE_ROOT },
+            { datasetPath: '.vscode-server', localPath: path_1.default.join(home, '.vscode-server') },
+            { datasetPath: '.config/code-server', localPath: path_1.default.join(home, '.config', 'code-server') },
+        ];
+    }
     /**
      * Internal helper for asynchronous execution with logging.
      */
@@ -25,7 +37,7 @@ class HFStorage {
                 HF_TOKEN: this.HF_TOKEN,
                 HF_HOME: '/tmp/.cache/huggingface',
                 TMPDIR: '/tmp',
-                PATH: `/home/node/.local/bin:/home/node/.nix-profile/bin:/usr/local/bin:/usr/bin:${process.env.PATH}`
+                PATH: `/home/node/.local/bin:/home/node/.nix-profile/bin:/usr/local/bin:/usr/bin:${process.env.PATH}`,
             };
             const child = (0, child_process_1.spawn)('/bin/bash', ['-c', command], {
                 env: spawnEnv
@@ -60,16 +72,15 @@ class HFStorage {
             const tmpDir = '/tmp/hf-sync';
             if (!fs_1.default.existsSync(tmpDir))
                 fs_1.default.mkdirSync(tmpDir, { recursive: true });
-            // 🟢 DELTA SYNCING: Only sync the specific workspace and IDE state directories
             const home = process.env.HOME || '/home/node';
-            const persistDirs = ['w', '.vscode-server', '.config/code-server'];
-            for (const dir of persistDirs) {
-                const localPath = path_1.default.join(home, dir);
-                if (!fs_1.default.existsSync(localPath))
-                    fs_1.default.mkdirSync(localPath, { recursive: true });
-                const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli download ${this.HF_DATASET_ID} --local-dir ${localPath} --include "${dir}/*" --token ${this.HF_TOKEN}) || (hf download ${this.HF_DATASET_ID} --local-dir ${localPath} --include "${dir}/*" --token ${this.HF_TOKEN})`;
-                onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Restoring ${dir} from differential profile...`);
-                await this.execAsync(cmd, onLog).catch(() => { }); // Continue if one dir fails
+            const persistenceEntries = this.getPersistenceEntries();
+            for (const entry of persistenceEntries) {
+                if (!fs_1.default.existsSync(entry.localPath)) {
+                    fs_1.default.mkdirSync(entry.localPath, { recursive: true });
+                }
+                const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli download ${this.HF_DATASET_ID} --local-dir ${home} --include "${entry.datasetPath}/*" --token ${this.HF_TOKEN}) || (hf download ${this.HF_DATASET_ID} --local-dir ${home} --include "${entry.datasetPath}/*" --token ${this.HF_TOKEN})`;
+                onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Restoring ${entry.datasetPath} from differential profile...`);
+                await this.execAsync(cmd, onLog).catch(() => { });
             }
             onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Profile restoration complete.`);
         }
@@ -86,15 +97,13 @@ class HFStorage {
             return;
         try {
             onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Saving persistent profile to '${this.HF_DATASET_ID}'...`);
-            const home = process.env.HOME || '/home/node';
-            const persistDirs = ['w', '.vscode-server', '.config/code-server'];
-            for (const dir of persistDirs) {
-                const localPath = path_1.default.join(home, dir);
-                if (!fs_1.default.existsSync(localPath))
+            const persistenceEntries = this.getPersistenceEntries();
+            for (const entry of persistenceEntries) {
+                if (!fs_1.default.existsSync(entry.localPath))
                     continue;
-                const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli upload ${this.HF_DATASET_ID} ${localPath} ${dir} --token ${this.HF_TOKEN} --message "CodeVerse Sync [${dir}]: ${new Date().toISOString()}" --exclude "node_modules/*" --exclude ".nix/*" --exclude ".direnv/*" --exclude ".cache/*") || (hf upload ${this.HF_DATASET_ID} ${localPath} ${dir} --token ${this.HF_TOKEN})`;
-                onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Performing differential backup of ${dir}...`);
-                await this.execAsync(cmd, onLog).catch(err => onLog === null || onLog === void 0 ? void 0 : onLog(`[WARN] Sync failed for ${dir}: ${err.message}`));
+                const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli upload ${this.HF_DATASET_ID} ${entry.localPath} ${entry.datasetPath} --token ${this.HF_TOKEN} --message "CodeVerse Sync [${entry.datasetPath}]: ${new Date().toISOString()}" --exclude "node_modules/*" --exclude ".nix/*" --exclude ".direnv/*" --exclude ".cache/*") || (hf upload ${this.HF_DATASET_ID} ${entry.localPath} ${entry.datasetPath} --token ${this.HF_TOKEN})`;
+                onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Performing differential backup of ${entry.datasetPath}...`);
+                await this.execAsync(cmd, onLog).catch((err) => onLog === null || onLog === void 0 ? void 0 : onLog(`[WARN] Sync failed for ${entry.datasetPath}: ${err.message}`));
             }
             onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Profile backup successful.`);
         }

dist/lib/idx/idx-engine.js

@@ -13,10 +13,10 @@ const child_process_1 = require("child_process");
  */
 class IdxEngine {
     static async hasCommand(command) {
-        const probeCommand = process.platform === 'win32' ? 'where' : 'command';
-        const probeArgs = process.platform === 'win32' ? [command] : ['-v', command];
+        const probeCommand = process.platform === 'win32' ? 'where' : 'which';
+        const probeArgs = [command];
         return await new Promise((resolve) => {
-            const child = (0, child_process_1.spawn)(probeCommand, probeArgs, { shell: process.platform !== 'win32' });
+            const child = (0, child_process_1.spawn)(probeCommand, probeArgs, { shell: false });
             child.on('close', (code) => resolve(code === 0));
             child.on('error', () => resolve(false));
         });

dist/server.js

@@ -65,8 +65,8 @@ const constants_1 = require("./constants");
 /**
  * PRODUCTION HARDENING (April 2026): Force writable temp paths for HF Spaces.
  */
-process.env.TMPDIR = constants_1.INFRA_CONFIG.TMPDIR;
-process.env.HF_HOME = constants_1.INFRA_CONFIG.HF_HOME;
+process.env.TMPDIR = env_config_1.ENV_CONFIG.TMPDIR;
+process.env.HF_HOME = env_config_1.ENV_CONFIG.HF_HOME;
 if (!process.env.HOME)
     process.env.HOME = '/home/node';
 const dev = process.env.NODE_ENV !== "production";
@@ -355,7 +355,7 @@ io.on("connection", (socket) => {
         shell = pty.spawn(process.env.SHELL || (os_1.default.platform() === "win32" ? "powershell.exe" : "bash"), [], {
             cols: cols || 80,
             rows: rows || 24,
-            cwd: constants_1.INFRA_CONFIG.WORKSPACE_ROOT,
+            cwd: env_config_1.ENV_CONFIG.WORKSPACE_ROOT,
             env: process.env,
         });
         shell.onData((data) => socket.emit("terminal:data", data));

lib/docker/manager.ts

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import { spawn, ChildProcess, execSync } from 'child_process';
+import { spawn, ChildProcess, execFileSync, execSync } from 'child_process';
 import path from 'path';
 import Docker from 'dockerode';
 import { EventEmitter } from 'events';
@@ -46,6 +46,14 @@ interface WorkspaceRuntimePaths {
     npmCachePath: string;
 }
 
+interface CodeServerLaunch {
+    command: string;
+    args: string[];
+    label: string;
+    usesNpx: boolean;
+    useShell: boolean;
+}
+
 const SHORT_WORKSPACE_ID_LENGTH = 8;
 const RUNTIME_ROOT_DIR_NAME = '.codeverse-runtime';
 
@@ -170,22 +178,74 @@ function findAvailablePort(): number {
     return port;
 }
 
-function resolveCodeServerLaunch(): { command: string; args: string[]; label: string } {
+function resolveExecutableOnPath(candidates: string[]): string | null {
+    const locatorCommand = process.platform === 'win32' ? 'where' : 'which';
+
+    for (const candidate of candidates) {
+        try {
+            const output = execFileSync(locatorCommand, [candidate], {
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            const resolvedPath = output
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .find(Boolean);
+            if (resolvedPath) {
+                return resolvedPath;
+            }
+        } catch {
+            // Fall through to the next candidate.
+        }
+    }
+
+    return null;
+}
+
+function quoteWindowsCmdArg(value: string): string {
+    if (value.length === 0) {
+        return '""';
+    }
+
+    if (!/[ \t"]/.test(value)) {
+        return value;
+    }
+
+    return `"${value.replace(/"/g, '""')}"`;
+}
+
+function resolveCodeServerLaunch(): CodeServerLaunch {
     const overrideBinary = process.env.CODE_SERVER_BIN;
     if (overrideBinary) {
-        return { command: overrideBinary, args: [], label: overrideBinary };
+        const useShell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(overrideBinary);
+        return { command: overrideBinary, args: [], label: overrideBinary, usesNpx: false, useShell };
     }
 
     if (process.platform === 'win32') {
-        try {
-            execSync('where code-server.cmd', { stdio: 'ignore' });
-            return { command: 'code-server.cmd', args: [], label: 'code-server' };
-        } catch {
-            return { command: 'npx.cmd', args: ['--yes', 'code-server'], label: 'npx code-server' };
+        const codeServerBinary = resolveExecutableOnPath(['code-server.exe', 'code-server']);
+        if (codeServerBinary) {
+            return { command: codeServerBinary, args: [], label: 'code-server', usesNpx: false, useShell: false };
         }
+
+        const npxCliPath = path.join(path.dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npx-cli.js');
+        if (fs.existsSync(npxCliPath)) {
+            return { command: process.execPath, args: [npxCliPath, '--yes', 'code-server'], label: 'node npx-cli.js code-server', usesNpx: true, useShell: false };
+        }
+
+        throw new Error('CODE_SERVER_BIN_NOT_FOUND');
+    }
+
+    const codeServerBinary = resolveExecutableOnPath(['code-server']);
+    if (codeServerBinary) {
+        return { command: codeServerBinary, args: [], label: 'code-server', usesNpx: false, useShell: false };
+    }
+
+    const npxBinary = resolveExecutableOnPath(['npx']);
+    if (npxBinary) {
+        return { command: npxBinary, args: ['--yes', 'code-server'], label: 'npx code-server', usesNpx: true, useShell: false };
     }
 
-    return { command: 'code-server', args: [], label: 'code-server' };
+    throw new Error('CODE_SERVER_BIN_NOT_FOUND');
 }
 
 /**
@@ -337,6 +397,13 @@ async function performProvisioning(config: WorkspaceConfig): Promise<WorkspaceOp
         const codeServerLaunch = resolveCodeServerLaunch();
         const shellCommand = codeServerLaunch.command;
         const args = codeServerLaunch.args;
+        const spawnCwd = (() => {
+            try {
+                return fs.realpathSync(workspacePath);
+            } catch {
+                return workspacePath;
+            }
+        })();
         
         const baseArgs = [
             '--auth', 'none',
@@ -356,11 +423,25 @@ async function performProvisioning(config: WorkspaceConfig): Promise<WorkspaceOp
         delete spawnEnv.PORT;
         delete spawnEnv.SERVER_PORT;
 
-        const child = spawn(shellCommand, [...args, ...baseArgs], {
-            env: spawnEnv,
-            cwd: workspacePath,
-            shell: false
-        });
+        const launchArgs = [...args, ...baseArgs];
+        const launchCommand = codeServerLaunch.useShell ? (process.env.ComSpec || 'cmd.exe') : shellCommand;
+        const launchCommandArgs = codeServerLaunch.useShell
+            ? ['/d', '/s', '/c', [quoteWindowsCmdArg(shellCommand), ...launchArgs.map(quoteWindowsCmdArg)].join(' ')]
+            : launchArgs;
+
+        log(`IDE launch prepared. Binary: ${shellCommand} | cwd: ${spawnCwd} | target: ${workspacePath}`);
+
+        let child: ChildProcess;
+        try {
+            child = spawn(launchCommand, launchCommandArgs, {
+                env: spawnEnv,
+                cwd: spawnCwd,
+                shell: false
+            });
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`IDE_SPAWN_CONFIGURATION_REJECTED: ${errorMessage}`);
+        }
 
         log(`Spawning VS Code Orchestrator via ${codeServerLaunch.label} (PID: ${child.pid})...`);
         let childExited = false;
@@ -370,13 +451,13 @@ async function performProvisioning(config: WorkspaceConfig): Promise<WorkspaceOp
             childFailureReason = `IDE_BINARY_FAILURE: ${err.message}`;
             log(`[FATAL] IDE binary failure: ${err.message}`);
         });
-        child.stdout.on('data', (data) => {
+        child.stdout?.on('data', (data) => {
             const out = data.toString().trim();
             if (out.includes('listening on')) log(`[IDX:UP] ${out}`);
             else if (out.length > 0) log(`[IDE:CORE] ${out}`);
         });
 
-        child.stderr.on('data', (data) => {
+        child.stderr?.on('data', (data) => {
             const err = data.toString().trim();
             if (err.length > 0) log(`[IDE:ERR] ${err}`);
         });
@@ -398,7 +479,7 @@ async function performProvisioning(config: WorkspaceConfig): Promise<WorkspaceOp
         while (attempts < 60) {
             if (childExited) {
                 const rawFailureMessage = childFailureReason ?? 'IDE_PROCESS_EXITED_BEFORE_HANDSHAKE';
-                const failureMessage = shellCommand === 'npx'
+                const failureMessage = codeServerLaunch.usesNpx
                     ? `${rawFailureMessage}. code-server could not be bootstrapped via npx. Install code-server globally or set CODE_SERVER_BIN.`
                     : rawFailureMessage;
                 log(`[FATAL] IDE bootstrap aborted before handshake: ${failureMessage}`);
@@ -448,7 +529,7 @@ async function performProvisioning(config: WorkspaceConfig): Promise<WorkspaceOp
         const error = e instanceof Error ? e.message : String(e);
         log(`[FATAL] Provisioning pipeline collapsed: ${error}`);
         nativeProcesses.delete(config.id);
-        const errResult = { success: false, error: "PROVISIONING_FAILED" };
+        const errResult = { success: false, error: `PROVISIONING_FAILED: ${error}` };
         provisioningBus.emit(`error:${config.id}`, errResult);
         return errResult;
     }

lib/hf/storage.ts

@@ -16,17 +16,31 @@ export class HFStorage {
         return Boolean(ENV_CONFIG.SPACE_ID && this.HF_TOKEN && this.HF_DATASET_ID && process.platform !== 'win32');
     }
 
+    private static getPersistenceEntries(): Array<{ datasetPath: string; localPath: string }> {
+        const home = process.env.HOME || '/home/node';
+        const relativeWorkspaceRoot = path.relative(home, this.WORKSPACE_ROOT).replace(/\\/g, '/');
+        const workspaceDatasetPath = relativeWorkspaceRoot.startsWith('..')
+            ? path.basename(this.WORKSPACE_ROOT)
+            : relativeWorkspaceRoot;
+
+        return [
+            { datasetPath: workspaceDatasetPath, localPath: this.WORKSPACE_ROOT },
+            { datasetPath: '.vscode-server', localPath: path.join(home, '.vscode-server') },
+            { datasetPath: '.config/code-server', localPath: path.join(home, '.config', 'code-server') },
+        ];
+    }
+
     /**
      * Internal helper for asynchronous execution with logging.
      */
     private static async execAsync(command: string, onLog?: (msg: string) => void): Promise<void> {
         return new Promise((resolve, reject) => {
-            const spawnEnv = { 
-                ...process.env, 
+            const spawnEnv = {
+                ...process.env,
                 HF_TOKEN: this.HF_TOKEN,
                 HF_HOME: '/tmp/.cache/huggingface',
                 TMPDIR: '/tmp',
-                PATH: `/home/node/.local/bin:/home/node/.nix-profile/bin:/usr/local/bin:/usr/bin:${process.env.PATH}` 
+                PATH: `/home/node/.local/bin:/home/node/.nix-profile/bin:/usr/local/bin:/usr/bin:${process.env.PATH}`,
             };
             const child = spawn('/bin/bash', ['-c', command], {
                 env: spawnEnv
@@ -63,19 +77,20 @@ export class HFStorage {
             const tmpDir = '/tmp/hf-sync';
             if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true });
 
-        // 🟢 DELTA SYNCING: Only sync the specific workspace and IDE state directories
-        const home = process.env.HOME || '/home/node';
-        const persistDirs = ['w', '.vscode-server', '.config/code-server'];
-        
-        for (const dir of persistDirs) {
-            const localPath = path.join(home, dir);
-            if (!fs.existsSync(localPath)) fs.mkdirSync(localPath, { recursive: true });
-            
-            const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli download ${this.HF_DATASET_ID} --local-dir ${localPath} --include "${dir}/*" --token ${this.HF_TOKEN}) || (hf download ${this.HF_DATASET_ID} --local-dir ${localPath} --include "${dir}/*" --token ${this.HF_TOKEN})`;
-            onLog?.(`[HF:STORAGE] Restoring ${dir} from differential profile...`);
-            await this.execAsync(cmd, onLog).catch(() => {}); // Continue if one dir fails
-        }
-        onLog?.(`[HF:STORAGE] Profile restoration complete.`);
+            const home = process.env.HOME || '/home/node';
+            const persistenceEntries = this.getPersistenceEntries();
+
+            for (const entry of persistenceEntries) {
+                if (!fs.existsSync(entry.localPath)) {
+                    fs.mkdirSync(entry.localPath, { recursive: true });
+                }
+
+                const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli download ${this.HF_DATASET_ID} --local-dir ${home} --include "${entry.datasetPath}/*" --token ${this.HF_TOKEN}) || (hf download ${this.HF_DATASET_ID} --local-dir ${home} --include "${entry.datasetPath}/*" --token ${this.HF_TOKEN})`;
+                onLog?.(`[HF:STORAGE] Restoring ${entry.datasetPath} from differential profile...`);
+                await this.execAsync(cmd, onLog).catch(() => {});
+            }
+
+            onLog?.(`[HF:STORAGE] Profile restoration complete.`);
         } catch (e: unknown) {
             const errorMessage = e instanceof Error ? e.message : String(e);
             onLog?.(`[ERROR] Profile restoration failed: ${errorMessage}`);
@@ -90,16 +105,14 @@ export class HFStorage {
 
         try {
             onLog?.(`[HF:STORAGE] Saving persistent profile to '${this.HF_DATASET_ID}'...`);
-            const home = process.env.HOME || '/home/node';
-            const persistDirs = ['w', '.vscode-server', '.config/code-server'];
+            const persistenceEntries = this.getPersistenceEntries();
 
-            for (const dir of persistDirs) {
-                const localPath = path.join(home, dir);
-                if (!fs.existsSync(localPath)) continue;
+            for (const entry of persistenceEntries) {
+                if (!fs.existsSync(entry.localPath)) continue;
 
-                const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli upload ${this.HF_DATASET_ID} ${localPath} ${dir} --token ${this.HF_TOKEN} --message "CodeVerse Sync [${dir}]: ${new Date().toISOString()}" --exclude "node_modules/*" --exclude ".nix/*" --exclude ".direnv/*" --exclude ".cache/*") || (hf upload ${this.HF_DATASET_ID} ${localPath} ${dir} --token ${this.HF_TOKEN})`;
-                onLog?.(`[HF:STORAGE] Performing differential backup of ${dir}...`);
-                await this.execAsync(cmd, onLog).catch(err => onLog?.(`[WARN] Sync failed for ${dir}: ${err.message}`));
+                const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli upload ${this.HF_DATASET_ID} ${entry.localPath} ${entry.datasetPath} --token ${this.HF_TOKEN} --message "CodeVerse Sync [${entry.datasetPath}]: ${new Date().toISOString()}" --exclude "node_modules/*" --exclude ".nix/*" --exclude ".direnv/*" --exclude ".cache/*") || (hf upload ${this.HF_DATASET_ID} ${entry.localPath} ${entry.datasetPath} --token ${this.HF_TOKEN})`;
+                onLog?.(`[HF:STORAGE] Performing differential backup of ${entry.datasetPath}...`);
+                await this.execAsync(cmd, onLog).catch((err: Error) => onLog?.(`[WARN] Sync failed for ${entry.datasetPath}: ${err.message}`));
             }
             onLog?.(`[HF:STORAGE] Profile backup successful.`);
         } catch (e: unknown) {
@@ -115,7 +128,7 @@ export class HFStorage {
     static startAutoSave(intervalMs: number = 300000) {
         if (this.autoSaveStarted || !this.isPersistenceRuntimeEnabled) return;
         this.autoSaveStarted = true;
-        
+
         console.log(`[HF:STORAGE] Persistence heartbeat initialized (Interval: ${intervalMs}ms)`);
         setInterval(async () => {
             await this.syncToDataset((msg) => console.log(msg)).catch(() => {});

lib/idx/idx-engine.ts

@@ -17,11 +17,11 @@ export interface IdxConfig {
  */
 export class IdxEngine {
   private static async hasCommand(command: string): Promise<boolean> {
-    const probeCommand = process.platform === 'win32' ? 'where' : 'command';
-    const probeArgs = process.platform === 'win32' ? [command] : ['-v', command];
+    const probeCommand = process.platform === 'win32' ? 'where' : 'which';
+    const probeArgs = [command];
 
     return await new Promise<boolean>((resolve) => {
-      const child = spawn(probeCommand, probeArgs, { shell: process.platform !== 'win32' });
+      const child = spawn(probeCommand, probeArgs, { shell: false });
       child.on('close', (code) => resolve(code === 0));
       child.on('error', () => resolve(false));
     });

lib/system/vitals.ts

@@ -0,0 +1,17 @@
+export interface SystemVitals {
+    rss: number;
+    heapUsed: number;
+    heapTotal: number;
+    loadAvg: [number, number, number];
+    uptime: number;
+    systemMemory: {
+        free: number;
+        total: number;
+    };
+    nodeVersion: string;
+}
+
+export interface SystemVitalsResponse {
+    success: true;
+    vitals: SystemVitals;
+}

server.ts

@@ -24,15 +24,15 @@ import { getNativeWorkspacePort, isNativeWorkspaceRunning, prewarmWorkspace, rec
 import { initDb } from "./lib/db/schema";
 import { client as dbClient } from "./lib/db";
 import { HFStorage } from "./lib/hf/storage";
-import { validateEnvironment } from "./lib/env-config";
+import { ENV_CONFIG, validateEnvironment } from "./lib/env-config";
 import httpProxy from "http-proxy";
 import { APP_CONFIG, INFRA_CONFIG, UI_STRINGS } from "./constants";
 
 /**
  * PRODUCTION HARDENING (April 2026): Force writable temp paths for HF Spaces.
  */
-process.env.TMPDIR = INFRA_CONFIG.TMPDIR;
-process.env.HF_HOME = INFRA_CONFIG.HF_HOME;
+process.env.TMPDIR = ENV_CONFIG.TMPDIR;
+process.env.HF_HOME = ENV_CONFIG.HF_HOME;
 if (!process.env.HOME) process.env.HOME = '/home/node';
 
 const dev = process.env.NODE_ENV !== "production";
@@ -358,7 +358,7 @@ io.on("connection", (socket) => {
         shell = pty.spawn(process.env.SHELL || (os.platform() === "win32" ? "powershell.exe" : "bash"), [], {
             cols: cols || 80,
             rows: rows || 24,
-            cwd: INFRA_CONFIG.WORKSPACE_ROOT,
+            cwd: ENV_CONFIG.WORKSPACE_ROOT,
             env: process.env as Record<string, string>,
         });
         shell.onData((data: string) => socket.emit("terminal:data", data));