// Check for "path" parameter (single file)
 if path, err := in.GetString("path"); err == nil {
-	paths = append(paths, path)
+	paths = append(paths, strings.Trim(strings.TrimSpace(path), "/"))
 } else if !rc.IsErrParamNotFound(err) {
 	return nil, err
 }
 
 // Check for multiple path parameters (path1, path2, etc.)
 for i := 1; ; i++ {
 	key := "path" + strconv.Itoa(i)
 	path, pathErr := in.GetString(key)
 	if pathErr != nil {
 		if rc.IsErrParamNotFound(pathErr) {
 			break // No more path parameters
 		}
 		return nil, pathErr
 	}
-	paths = append(paths, path)
+	paths = append(paths, strings.Trim(strings.TrimSpace(path), "/"))
 }
 
 // If no paths found, return error
 if len(paths) == 0 {
 	return nil, errors.New("no path parameter(s) provided")
 }

-percentage, ok := result["percentage"].(int)
-require.True(t, ok)
-assert.GreaterOrEqual(t, percentage, 0)
-assert.LessOrEqual(t, percentage, 100)
+// Use helper to normalize numeric type
+pct := getInt64FromParam(t, result, "percentage")
+assert.GreaterOrEqual(t, pct, int64(0))
+assert.LessOrEqual(t, pct, int64(100))

 func (item *Item) VFSStatusCacheWithPercentage() (string, int) {
+	// First snapshot state we need, then release lock before cross-struct calls
 	item.mu.Lock()
-	defer item.mu.Unlock()
+	writeBackID := item.writeBackID
+	hasWriteback := item.c != nil && item.c.writeback != nil
+	isDirty := item.info.Dirty
+	present := item._present()
+	cachedSize := item.info.Rs.Size()
+	totalSize := item.info.Size
+	item.mu.Unlock()
 
-	// Check if item is being uploaded
-	if item.writeBackID != 0 && item.c.writeback != nil {
-		// Check upload status with item lock released to avoid lock ordering issues
-		writeBackID := item.writeBackID
-		wb := item.c.writeback
-		item.mu.Unlock()
-		isUploading := wb.IsUploading(writeBackID)
-		item.mu.Lock()
-		if isUploading {
+	// Check upload status without holding item.mu
+	if writeBackID != 0 && hasWriteback {
+		if item.c.writeback.IsUploading(writeBackID) {
 			return "UPLOADING", 100
 		}
 	}
 
-	// Check if item is dirty (modified but not uploaded yet)
+	// Re-lock to ensure status decisions are based on up-to-date state
+	item.mu.Lock()
+	defer item.mu.Unlock()
+
+	// Re-validate critical fields in case they changed while unlocked
 	if item.info.Dirty {
 		return "DIRTY", 100
 	}
-
-	// Check cache status
 	if item._present() {
 		return "FULL", 100
 	}
 
-	cachedSize := item.info.Rs.Size()
-	totalSize := item.info.Size
+	cachedSize = item.info.Rs.Size()
+	totalSize = item.info.Size
 
 	if totalSize <= 0 {
 		if cachedSize > 0 {
 			return "PARTIAL", 99
 		}
 		return "NONE", 0
 	}
-
 	if cachedSize >= totalSize {
 		return "FULL", 100
 	}
 	if cachedSize > 0 {
 		percentage := int((cachedSize * 100) / totalSize)
 		return "PARTIAL", percentage
 	}
-
 	return "NONE", 0
 }

-percentage, ok := result["percentage"].(int)
-require.True(t, ok)
+// helper to get int percentage robustly
+getInt := func(t *testing.T, m rc.Params, key string) int {
+	t.Helper()
+	v, ok := m[key]
+	require.True(t, ok, "missing key %q", key)
+	switch n := v.(type) {
+	case int:
+		return n
+	case int64:
+		return int(n)
+	case float64:
+		return int(n)
+	default:
+		require.Failf(t, "type mismatch", "key %q has unexpected type %T", key, v)
+		return 0
+	}
+}
+percentage := getInt(t, result, "percentage")
 assert.GreaterOrEqual(t, percentage, 0)
 assert.LessOrEqual(t, percentage, 100)

 func (item *Item) VFSStatusCacheWithPercentage() (string, int) {
+	// Capture snapshot under lock
+	item.mu.Lock()
+	writeBackID := item.writeBackID
+	hasWriteback := item.c != nil && item.c.writeback != nil
+	isDirty := item.info.Dirty
+	present := item.info.Rs.Present(ranges.Range{Pos: 0, Size: item.info.Size})
+	cachedSize := item.info.Rs.Size()
+	totalSize := item.info.Size
+	item.mu.Unlock()
+
+	// Check if item is being uploaded without holding item.mu to avoid lock ordering issues
+	if writeBackID != 0 && hasWriteback && item.c.writeback.IsUploading(writeBackID) {
+		return "UPLOADING", 100
+	}
+
+	// Re-lock to make final decision based on up-to-date state
 	item.mu.Lock()
 	defer item.mu.Unlock()
 
-	// Check if item is being uploaded
-	if item.writeBackID != 0 && item.c.writeback != nil {
-		// Check upload status with item lock released to avoid lock ordering issues
-		writeBackID := item.writeBackID
-		wb := item.c.writeback
-		item.mu.Unlock()
-		isUploading := wb.IsUploading(writeBackID)
-		item.mu.Lock()
-		if isUploading {
-			return "UPLOADING", 100
-		}
-	}
-
-	// Check if item is dirty (modified but not uploaded yet)
 	if item.info.Dirty {
 		return "DIRTY", 100
 	}
-
-	// Check cache status
-	if item._present() {
+	if item.info.Rs.Present(ranges.Range{Pos: 0, Size: item.info.Size}) {
 		return "FULL", 100
 	}
 
-	cachedSize := item.info.Rs.Size()
-	totalSize := item.info.Size
+	cachedSize = item.info.Rs.Size()
+	totalSize = item.info.Size
 
 	if totalSize <= 0 {
 		if cachedSize > 0 {
 			return "PARTIAL", 99
 		}
 		return "NONE", 0
 	}
-
 	if cachedSize >= totalSize {
 		return "FULL", 100
 	}
 	if cachedSize > 0 {
 		percentage := int((cachedSize * 100) / totalSize)
 		return "PARTIAL", percentage
 	}
-
 	return "NONE", 0
 }

 func (c *Cache) GetAggregateStats() CacheStats {
+	// Snapshot items under cache lock
 	c.mu.Lock()
-	defer c.mu.Unlock()
+	items := make([]*Item, 0, len(c.item))
+	for _, it := range c.item {
+		if it != nil {
+			items = append(items, it)
+		}
+	}
+	c.mu.Unlock()
 
 	stats := CacheStats{
-		TotalFiles:       len(c.item),
+		TotalFiles:       len(items),
 		TotalCachedBytes: 0,
 	}
-
-	if stats.TotalFiles == 0 {
+	if len(items) == 0 {
 		return stats
 	}
 
 	var totalPercentage int
-
-	for _, item := range c.item {
+	for _, item := range items {
+		if item == nil {
+			continue
+		}
 		status, percentage := item.VFSStatusCacheWithPercentage()
-
 		switch status {
 		case "FULL":
 			stats.FullCount++
 		case "PARTIAL":
 			stats.PartialCount++
 		case "NONE":
 			stats.NoneCount++
 		case "DIRTY":
 			stats.DirtyCount++
 		case "UPLOADING":
 			stats.UploadingCount++
 		}
-
 		stats.TotalCachedBytes += item.getDiskSize()
 		totalPercentage += percentage
 	}
-
-	// Calculate average percentage
-	if stats.TotalFiles > 0 {
-		stats.AverageCachePercentage = totalPercentage / stats.TotalFiles
-	}
-
+	stats.AverageCachePercentage = totalPercentage / len(items)
 	return stats
 }

 func rcDirStatus(ctx context.Context, in rc.Params) (out rc.Params, err error) {
 	vfs, err := getVFS(in)
 	if err != nil {
 		return nil, err
 	}
-...
-	// Read directory contents
-	err = targetDir._readDir()
+
+	dirPath, err := in.GetString("dir")
+	if err != nil && !rc.IsErrParamNotFound(err) {
+		return nil, err
+	}
+
+	root, err := vfs.Root()
 	if err != nil {
+		return nil, err
+	}
+
+	targetDir := root
+	if dirPath != "" {
+		node, err := vfs.Stat(dirPath)
+		if err != nil {
+			return nil, fmt.Errorf("directory not found: %w", err)
+		}
+		var ok bool
+		targetDir, ok = node.(*Dir)
+		if !ok {
+			return nil, fmt.Errorf("target path %q is not a directory", dirPath)
+		}
+	}
+
+	// Use exported method to populate directory entries safely
+	if err := targetDir.readDir(); err != nil {
 		return nil, fmt.Errorf("failed to read directory: %w", err)
 	}
+	nodes, err := targetDir.ReadDirAll()
+	if err != nil {
+		return nil, fmt.Errorf("failed to list directory contents: %w", err)
+	}
 
-	// Get all nodes in the directory
-	nodes, err := targetDir.ReadDirAll()
+	var results []rc.Params
+	for _, node := range nodes {
+		if file, ok := node.(*File); ok {
+			if vfs.cache == nil {
+				results = append(results, rc.Params{"name": file.Name(), "status": "NONE", "percentage": 0})
+			} else {
+				item := vfs.cache.Item(file.Path())
+				if item == nil {
+					results = append(results, rc.Params{"name": file.Name(), "status": "NONE", "percentage": 0})
+					continue
+				}
+				status, percentage := item.VFSStatusCacheWithPercentage()
+				results = append(results, rc.Params{"name": file.Name(), "status": status, "percentage": percentage})
+			}
+		}
+	}
+	return rc.Params{"files": results}, nil
+}

-	// Read directory contents
-	err = targetDir._readDir()
-	if err != nil {
-		return nil, fmt.Errorf("failed to read directory: %w", err)
-	}
-
 	// Get all nodes in the directory
 	nodes, err := targetDir.ReadDirAll()
 	if err != nil {
 		return nil, fmt.Errorf("failed to list directory contents: %w", err)
 	}

 	// dir parameter is optional - defaults to root
-	dirPath, _ := in.GetString("dir")
-	if err != nil && dirPath != "" {
+	dirPath, err := in.GetString("dir")
+	if err != nil && !errors.Is(err, rc.ErrParamNotFound) {
 		return nil, err
 	}

 	if cachedSize > 0 {
 		percentage := int((cachedSize * 100) / totalSize)
-		if percentage > 99 {
-			percentage = 99
-		}
 		return "PARTIAL", percentage
 	}