frontend/src/components/fileManager/FileHistoryGroup.tsx

@@ -10,7 +10,7 @@ interface FileHistoryGroupProps {
   isExpanded: boolean;
   onDownloadSingle: (file: StirlingFileStub) => void;
   onFileDoubleClick: (file: StirlingFileStub) => void;
-  onHistoryFileRemove: (file: StirlingFileStub) => void;
+  onFileRemove: (index: number) => void;
   isFileSupported: (fileName: string) => boolean;
 }
 
@@ -20,7 +20,7 @@ const FileHistoryGroup: React.FC<FileHistoryGroupProps> = ({
   isExpanded,
   onDownloadSingle,
   onFileDoubleClick,
-  onHistoryFileRemove,
+  onFileRemove,
   isFileSupported,
 }) => {
   const { t } = useTranslation();
@@ -44,14 +44,14 @@ const FileHistoryGroup: React.FC<FileHistoryGroupProps> = ({
         </Group>
 
         <Box ml="md">
-          {sortedHistory.map((historyFile, _index) => (
+          {sortedHistory.map((historyFile, index) => (
             <FileListItem
               key={`history-${historyFile.id}-${historyFile.versionNumber || 1}`}
               file={historyFile}
               isSelected={false} // History files are not selectable
               isSupported={isFileSupported(historyFile.name)}
               onSelect={() => {}} // No selection for history files
-              onRemove={() => onHistoryFileRemove(historyFile)} // Remove specific history file
+              onRemove={() => onFileRemove(index)} // Pass through remove handler
               onDownload={() => onDownloadSingle(historyFile)}
               onDoubleClick={() => onFileDoubleClick(historyFile)}
               isHistoryFile={true} // This enables "Add to Recents" in menu

frontend/src/components/fileManager/FileListArea.tsx

@@ -25,7 +25,6 @@ const FileListArea: React.FC<FileListAreaProps> = ({
     loadedHistoryFiles,
     onFileSelect,
     onFileRemove,
-    onHistoryFileRemove,
     onFileDoubleClick,
     onDownloadSingle,
     isFileSupported,
@@ -79,7 +78,7 @@ const FileListArea: React.FC<FileListAreaProps> = ({
                     isExpanded={isExpanded}
                     onDownloadSingle={onDownloadSingle}
                     onFileDoubleClick={onFileDoubleClick}
-                    onHistoryFileRemove={onHistoryFileRemove}
+                    onFileRemove={onFileRemove}
                     isFileSupported={isFileSupported}
                   />
                 </React.Fragment>

frontend/src/contexts/FileManagerContext.tsx

@@ -24,7 +24,6 @@ interface FileManagerContextValue {
   onLocalFileClick: () => void;
   onFileSelect: (file: StirlingFileStub, index: number, shiftKey?: boolean) => void;
   onFileRemove: (index: number) => void;
-  onHistoryFileRemove: (file: StirlingFileStub) => void;
   onFileDoubleClick: (file: StirlingFileStub) => void;
   onOpenFiles: () => void;
   onSearchChange: (value: string) => void;
@@ -173,7 +172,7 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
 
   // Helper function to safely determine which files can be deleted
   const getSafeFilesToDelete = useCallback((
-    fileIds: string[],
+    leafFileIds: string[],
     allStoredStubs: StirlingFileStub[]
   ): string[] => {
     const fileMap = new Map(allStoredStubs.map(f => [f.id as string, f]));
@@ -181,7 +180,7 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
     const filesToPreserve = new Set<string>();
 
     // First, identify all files in the lineages of the leaf files being deleted
-    for (const leafFileId of fileIds) {
+    for (const leafFileId of leafFileIds) {
       const currentFile = fileMap.get(leafFileId);
       if (!currentFile) continue;
 
@@ -207,7 +206,7 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
       const fileOriginalId = file.originalFileId || file.id;
 
       // If this file is a leaf node (not being deleted) and its lineage overlaps with files we want to delete
-      if (file.isLeaf !== false && !fileIds.includes(file.id)) {
+      if (file.isLeaf !== false && !leafFileIds.includes(file.id)) {
         // Find all files in this preserved lineage
         const preservedChainFiles = allStoredStubs.filter((chainFile: StirlingFileStub) =>
           (chainFile.originalFileId || chainFile.id) === fileOriginalId
@@ -219,50 +218,20 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
     }
 
     // Final list: files to delete minus files that must be preserved
-    let safeToDelete = Array.from(filesToDelete).filter(fileId => !filesToPreserve.has(fileId));
-
-    // Check for orphaned non-leaf files after main deletion
-    const remainingFiles = allStoredStubs.filter(file => !safeToDelete.includes(file.id as string));
-    const orphanedNonLeafFiles: string[] = [];
-
-    for (const file of remainingFiles) {
-      // Only check non-leaf files (files that have been processed and have children)
-      if (file.isLeaf === false) {
-        const fileOriginalId = file.originalFileId || file.id;
-        
-        // Check if this non-leaf file has any living descendants
-        const hasLivingDescendants = remainingFiles.some(otherFile => {
-          // Check if otherFile is a descendant of this file
-          const otherOriginalId = otherFile.originalFileId || otherFile.id;
-          return (
-            // Direct parent relationship
-            otherFile.parentFileId === file.id ||
-            // Same lineage but different from this file
-            (otherOriginalId === fileOriginalId && otherFile.id !== file.id)
-          );
-        });
-
-        if (!hasLivingDescendants) {
-          orphanedNonLeafFiles.push(file.id as string);
-        }
-      }
-    }
-
-    // Add orphaned non-leaf files to deletion list
-    safeToDelete = [...safeToDelete, ...orphanedNonLeafFiles];
+    const safeToDelete = Array.from(filesToDelete).filter(fileId => !filesToPreserve.has(fileId));
 
     console.log('Deletion analysis:', {
       candidatesForDeletion: Array.from(filesToDelete),
       mustPreserve: Array.from(filesToPreserve),
-      orphanedNonLeafFiles,
       safeToDelete
     });
 
     return safeToDelete;
   }, []);
 
-  // Shared internal delete logic
-  const performFileDelete = useCallback(async (fileToRemove: StirlingFileStub, fileIndex: number) => {
+  const handleFileRemove = useCallback(async (index: number) => {
+    const fileToRemove = filteredFiles[index];
+    if (fileToRemove) {
       const deletedFileId = fileToRemove.id;
 
       // Get all stored files to analyze lineages
@@ -311,68 +280,11 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
       }
 
       // Call the parent's deletion logic for the main file only
-    onFileRemove(fileIndex);
+      onFileRemove(index);
 
       // Refresh to ensure consistent state
       await refreshRecentFiles();
-  }, [getSafeFilesToDelete, setSelectedFileIds, setExpandedFileIds, setLoadedHistoryFiles, onFileRemove, refreshRecentFiles]);
-
-  const handleFileRemove = useCallback(async (index: number) => {
-    const fileToRemove = filteredFiles[index];
-    if (fileToRemove) {
-      await performFileDelete(fileToRemove, index);
     }
-  }, [filteredFiles, performFileDelete]);
-
-  // Handle deletion by fileId (more robust than index-based)
-  const handleFileRemoveById = useCallback(async (fileId: FileId) => {
-    // Find the file and its index in filteredFiles
-    const fileIndex = filteredFiles.findIndex(file => file.id === fileId);
-    const fileToRemove = filteredFiles[fileIndex];
-    
-    if (fileToRemove && fileIndex !== -1) {
-      await performFileDelete(fileToRemove, fileIndex);
-    }
-  }, [filteredFiles, performFileDelete]);
-
-  // Handle deletion of specific history files (not index-based)
-  const handleHistoryFileRemove = useCallback(async (fileToRemove: StirlingFileStub) => {
-    const deletedFileId = fileToRemove.id;
-
-    // Clear from expanded state to prevent ghost entries
-    setExpandedFileIds(prev => {
-      const newExpanded = new Set(prev);
-      newExpanded.delete(deletedFileId);
-      return newExpanded;
-    });
-
-    // Clear from history cache - remove all files in the chain
-    setLoadedHistoryFiles(prev => {
-      const newCache = new Map(prev);
-
-      // Remove cache entries for all deleted files
-      newCache.delete(deletedFileId);
-
-      // Also remove deleted files from any other file's history cache
-      for (const [mainFileId, historyFiles] of newCache.entries()) {
-        const filteredHistory = historyFiles.filter(histFile => deletedFileId != histFile.id);
-        if (filteredHistory.length !== historyFiles.length) {
-          newCache.set(mainFileId, filteredHistory);
-        }
-      }
-
-      return newCache;
-    });
-
-    // Delete safe files from IndexedDB
-    try {
-        await fileStorage.deleteStirlingFile(deletedFileId);
-    } catch (error) {
-      console.error('Failed to delete files from chain:', error);
-    }
-
-    // Refresh to ensure consistent state
-    await refreshRecentFiles();
   }, [filteredFiles, onFileRemove, refreshRecentFiles, getSafeFilesToDelete]);
 
   const handleFileDoubleClick = useCallback((file: StirlingFileStub) => {
@@ -425,14 +337,53 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
     if (selectedFileIds.length === 0) return;
 
     try {
-      // Delete each selected file using the proven single delete logic
-      for (const fileId of selectedFileIds) {
-        await handleFileRemoveById(fileId);
+      // Get all stored files to analyze lineages
+      const allStoredStubs = await fileStorage.getAllStirlingFileStubs();
+
+      // Get safe files to delete (respecting shared lineages)
+      const filesToDelete = getSafeFilesToDelete(selectedFileIds, allStoredStubs);
+
+      console.log(`Bulk safely deleting files and their history chains:`, filesToDelete);
+
+      // Update history cache synchronously
+      setLoadedHistoryFiles(prev => {
+        const newCache = new Map(prev);
+
+        // Remove cache entries for all deleted files
+        filesToDelete.forEach(id => newCache.delete(id as FileId));
+
+        // Also remove deleted files from any other file's history cache
+        for (const [mainFileId, historyFiles] of newCache.entries()) {
+          const filteredHistory = historyFiles.filter(histFile => !filesToDelete.includes(histFile.id as string));
+          if (filteredHistory.length !== historyFiles.length) {
+            newCache.set(mainFileId, filteredHistory);
           }
+        }
+
+        return newCache;
+      });
+
+      // Also clear any expanded state for deleted files to prevent ghost entries
+      setExpandedFileIds(prev => {
+        const newExpanded = new Set(prev);
+        filesToDelete.forEach(id => newExpanded.delete(id));
+        return newExpanded;
+      });
+
+      // Clear selection immediately to prevent ghost selections
+      setSelectedFileIds(prev => prev.filter(id => !filesToDelete.includes(id)));
+
+      // Delete safe files from IndexedDB
+      for (const fileId of filesToDelete) {
+        await fileStorage.deleteStirlingFile(fileId as FileId);
+      }
+
+      // Refresh the file list to get updated data
+      await refreshRecentFiles();
     } catch (error) {
       console.error('Failed to delete selected files:', error);
     }
-  }, [selectedFileIds, handleFileRemoveById]);
+  }, [selectedFileIds, filteredFiles, refreshRecentFiles, getSafeFilesToDelete]);
 
 
   const handleDownloadSelected = useCallback(async () => {
@@ -589,7 +540,6 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
     onLocalFileClick: handleLocalFileClick,
     onFileSelect: handleFileSelect,
     onFileRemove: handleFileRemove,
-    onHistoryFileRemove: handleHistoryFileRemove,
     onFileDoubleClick: handleFileDoubleClick,
     onOpenFiles: handleOpenFiles,
     onSearchChange: handleSearchChange,
@@ -620,8 +570,6 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
     handleLocalFileClick,
     handleFileSelect,
     handleFileRemove,
-    handleFileRemoveById,
-    performFileDelete,
     handleFileDoubleClick,
     handleOpenFiles,
     handleSearchChange,