feat(sidebar): delete folders from the sidebar (#999)

Folders created from the sidebar had no in-app way back out: the only removal path was to leave ComfyUI, delete the directory by hand and rescan. A typo'd folder also polluted the move/download destination picker permanently, since it reads the same all_folders source. Adds POST /api/lm/{prefix}/delete-folder, restricted to directories whose subtree holds no model weight files — a folder-level cascade would bypass the per-model lifecycle bookkeeping (metadata sidecars, previews, cache entries, pending-delete staging, recipe references). The service walks the directory itself instead of trusting the possibly stale cache, reports what it would remove (models / files / subfolders / symlinks), and refuses library roots, top-level symlinks (shutil.rmtree rejects those) and folders holding a staged delete, whose manifest would be invalidated by the move. Symbolic links inside the subtree are counted but never followed. ModelScanner.remove_known_folder mirrors add_known_folder: the removed subtree leaves all_folders while ancestors are kept (every recorded ancestor exists on disk in its own right), stale cache entries under the prefix are purged and the folder list recomputed. The handler broadcasts models_changed so destination pickers drop the folder too. The sidebar entry is a destructive context-menu item. The modal opens in a confirm state for model-free folders and an explanatory one when the subtree still holds models, decided from the models-only set that already dims empty nodes; a stale tree is caught by the 409 not_empty/busy conflict. Truly empty folders get the existing 20s undo affordance, implemented by re-creating the directory.
2026-09-20 18:51:26 -03:00 · 2026-09-15 20:05:10 +08:00
parent cc8eedcff7
commit 4938faa049
24 changed files with 1317 additions and 3 deletions
@@ -9,6 +9,7 @@ const {
  UI_HELPERS_MODULE,
  UPDATE_CHECK_MODULE,
  STATE_MODULE,
+  MODAL_MANAGER_MODULE,
 } = vi.hoisted(() => ({
  SIDEBAR_MANAGER_MODULE: new URL('../../../static/js/components/SidebarManager.js', import.meta.url).pathname,
  STORAGE_HELPERS_MODULE: new URL('../../../static/js/utils/storageHelpers.js', import.meta.url).pathname,
@@ -18,17 +19,23 @@ const {
  UI_HELPERS_MODULE: new URL('../../../static/js/utils/uiHelpers.js', import.meta.url).pathname,
  UPDATE_CHECK_MODULE: new URL('../../../static/js/utils/updateCheckHelpers.js', import.meta.url).pathname,
  STATE_MODULE: new URL('../../../static/js/state/index.js', import.meta.url).pathname,
+  MODAL_MANAGER_MODULE: new URL('../../../static/js/managers/ModalManager.js', import.meta.url).pathname,
 }));

 vi.mock(MODEL_API_FACTORY_MODULE, () => ({ getModelApiClient: vi.fn() }));
 vi.mock(I18N_MODULE, () => ({ translate: (key, _args, fallback) => fallback || key }));
 vi.mock(BULK_MANAGER_MODULE, () => ({ bulkManager: {} }));
-vi.mock(UI_HELPERS_MODULE, () => ({ showToast: vi.fn() }));
+vi.mock(UI_HELPERS_MODULE, () => ({ showToast: vi.fn(), showActionToast: vi.fn() }));
 vi.mock(UPDATE_CHECK_MODULE, () => ({ performFolderUpdateCheck: vi.fn() }));
+vi.mock(MODAL_MANAGER_MODULE, () => ({
+  modalManager: { showModal: vi.fn(), closeModal: vi.fn() },
+}));

 const { SidebarManager } = await import(SIDEBAR_MANAGER_MODULE);
 const { state } = await import(STATE_MODULE);
 const { setStorageItem, getStorageItem } = await import(STORAGE_HELPERS_MODULE);
+const { showToast, showActionToast } = await import(UI_HELPERS_MODULE);
+const { modalManager } = await import(MODAL_MANAGER_MODULE);

 function createApiClient(overrides = {}) {
  return {
@@ -44,6 +51,14 @@ function createApiClient(overrides = {}) {
    fetchModelFolders: vi.fn().mockResolvedValue({ folders: ['', 'full'] }),
    fetchModelRoots: vi.fn().mockResolvedValue({ roots: ['/models/loras'] }),
    createFolder: vi.fn().mockResolvedValue({ success: true, folder: 'new-folder', created: true }),
+    deleteFolder: vi.fn().mockResolvedValue({
+      success: true,
+      folder: 'empty',
+      model_count: 0,
+      file_count: 0,
+      dir_count: 0,
+      restorable: true,
+    }),
    ...overrides,
  };
 }
@@ -461,3 +476,204 @@ describe('SidebarManager folder creation', () => {
  });
 });

+describe('SidebarManager folder deletion', () => {
+  const MODAL_HTML = `
+    <div id="deleteFolderModal" class="modal delete-modal">
+      <div class="modal-content delete-modal-content">
+        <h2 data-role="title"></h2>
+        <p class="delete-message" data-role="message"></p>
+        <div class="delete-model-info" data-role="info"></div>
+        <div class="modal-actions">
+          <button class="cancel-btn" data-action="cancel-delete-folder">Cancel</button>
+          <button class="delete-btn" data-action="confirm-delete-folder">Delete folder</button>
+        </div>
+      </div>
+    </div>`;
+
+  function confirmBtn() {
+    return document.querySelector('#deleteFolderModal [data-action="confirm-delete-folder"]');
+  }
+
+  beforeEach(() => {
+    localStorage.clear();
+    document.body.innerHTML = MODAL_HTML;
+    state.global.settings = {};
+    vi.clearAllMocks();
+  });
+
+  it('opens the confirm state for a folder whose subtree holds no models', () => {
+    const manager = createManager(createApiClient());
+    manager.nonEmptyFolders = new Set(['', 'full']);
+
+    manager.showDeleteFolderModal('empty');
+
+    const modal = document.getElementById('deleteFolderModal');
+    expect(modal.dataset.state).toBe('confirm');
+    expect(confirmBtn().style.display).toBe('');
+    expect(manager._pendingDeleteFolderPath).toBe('empty');
+    expect(modalManager.showModal).toHaveBeenCalledWith('deleteFolderModal');
+  });
+
+  it('explains the refusal when the subtree still holds models', () => {
+    const manager = createManager(createApiClient());
+    manager.nonEmptyFolders = new Set(['', 'full']);
+
+    manager.showDeleteFolderModal('full');
+
+    const modal = document.getElementById('deleteFolderModal');
+    expect(modal.dataset.state).toBe('blocked');
+    expect(confirmBtn().style.display).toBe('none');
+    expect(manager._pendingDeleteFolderPath).toBeNull();
+  });
+
+  it('treats an unknown folder as model-free when the models-only set is missing', () => {
+    // nonEmptyFolders is null outside the include-empty tree; the server still
+    // refuses a non-empty folder, so the client falls back to the confirm state.
+    const manager = createManager(createApiClient());
+    manager.nonEmptyFolders = null;
+
+    manager.showDeleteFolderModal('empty');
+
+    expect(document.getElementById('deleteFolderModal').dataset.state).toBe('confirm');
+  });
+
+  it('deletes the folder and offers the undo affordance for an empty one', async () => {
+    const apiClient = createApiClient();
+    const manager = createManager(apiClient);
+    manager.refresh = vi.fn().mockResolvedValue(undefined);
+
+    const success = await manager._deleteFolder('empty');
+
+    expect(success).toBe(true);
+    expect(apiClient.deleteFolder).toHaveBeenCalledWith('/models/loras/empty');
+    expect(manager.refresh).toHaveBeenCalledTimes(1);
+    expect(showActionToast).toHaveBeenCalledTimes(1);
+    expect(showToast).not.toHaveBeenCalled();
+  });
+
+  it('restores a deleted empty folder through the create-folder API', async () => {
+    const apiClient = createApiClient();
+    const manager = createManager(apiClient);
+    manager.refresh = vi.fn().mockResolvedValue(undefined);
+
+    await manager._deleteFolder('empty');
+    const undo = showActionToast.mock.calls[0][3].onAction;
+    await undo();
+
+    expect(apiClient.createFolder).toHaveBeenCalledWith('/models/loras/empty');
+    expect(showToast).toHaveBeenCalledWith('sidebar.deleteFolderResult.restored', {}, 'success');
+  });
+
+  it('skips the undo affordance when non-model leftovers were removed', async () => {
+    const apiClient = createApiClient({
+      deleteFolder: vi.fn().mockResolvedValue({
+        success: true,
+        folder: 'empty',
+        file_count: 2,
+        dir_count: 1,
+        restorable: false,
+      }),
+    });
+    const manager = createManager(apiClient);
+    manager.refresh = vi.fn().mockResolvedValue(undefined);
+
+    await manager._deleteFolder('empty');
+
+    expect(showActionToast).not.toHaveBeenCalled();
+    expect(showToast).toHaveBeenCalledWith(
+      'sidebar.deleteFolderResult.successWithFiles',
+      { name: 'empty', count: 3 },
+      'success'
+    );
+  });
+
+  it('surfaces the not_empty conflict when the tree was stale', async () => {
+    const conflict = Object.assign(new Error('still contains models'), { code: 'not_empty' });
+    const apiClient = createApiClient({
+      deleteFolder: vi.fn().mockRejectedValue(conflict),
+    });
+    const manager = createManager(apiClient);
+    manager.refresh = vi.fn().mockResolvedValue(undefined);
+
+    const success = await manager._deleteFolder('full');
+
+    expect(success).toBe(false);
+    expect(showToast).toHaveBeenCalledWith('sidebar.deleteFolderResult.notEmpty', {}, 'warning');
+    expect(manager.refresh).not.toHaveBeenCalled();
+  });
+
+  it('surfaces a busy folder with a staged delete', async () => {
+    const busy = Object.assign(new Error('staged delete pending'), { code: 'busy' });
+    const apiClient = createApiClient({
+      deleteFolder: vi.fn().mockRejectedValue(busy),
+    });
+    const manager = createManager(apiClient);
+    manager.refresh = vi.fn().mockResolvedValue(undefined);
+
+    await manager._deleteFolder('full');
+
+    expect(showToast).toHaveBeenCalledWith('sidebar.deleteFolderResult.busy', {}, 'warning');
+  });
+
+  it('drops the removed subtree from the persisted expand state', () => {
+    const manager = createManager(createApiClient());
+    manager.expandedNodes = new Set(['empty', 'empty/deep', 'other']);
+    manager.saveExpandedState = vi.fn();
+
+    manager._forgetRemovedFolder('empty');
+
+    expect([...manager.expandedNodes]).toEqual(['other']);
+    expect(manager.saveExpandedState).toHaveBeenCalledTimes(1);
+  });
+
+  it('leaves the expand state untouched when nothing matched', () => {
+    const manager = createManager(createApiClient());
+    manager.expandedNodes = new Set(['other']);
+    manager.saveExpandedState = vi.fn();
+
+    manager._forgetRemovedFolder('empty');
+
+    expect([...manager.expandedNodes]).toEqual(['other']);
+    expect(manager.saveExpandedState).not.toHaveBeenCalled();
+  });
+
+  it('routes the modal buttons to cancel and confirm', () => {
+    const manager = createManager(createApiClient());
+    manager._deleteFolder = vi.fn().mockResolvedValue(true);
+    manager._pendingDeleteFolderPath = 'empty';
+    manager._wireDeleteFolderModal();
+
+    confirmBtn().dispatchEvent(new MouseEvent('click', { bubbles: true }));
+
+    expect(modalManager.closeModal).toHaveBeenCalledWith('deleteFolderModal');
+    expect(manager._deleteFolder).toHaveBeenCalledWith('empty');
+  });
+
+  it('routes the context-menu action to the delete modal', () => {
+    const manager = createManager(createApiClient());
+    manager.showDeleteFolderModal = vi.fn();
+
+    manager._performFolderAction('delete-folder', 'empty');
+
+    expect(manager.showDeleteFolderModal).toHaveBeenCalledWith('empty');
+  });
+
+  it('hides the delete entry when folder management is unsupported', () => {
+    document.body.insertAdjacentHTML('beforeend', `
+      <div id="sidebarFolderContextMenu" class="context-menu">
+        <div class="context-menu-item" data-action="create-subfolder"></div>
+        <div class="context-menu-item delete-item" data-action="delete-folder"></div>
+      </div>`);
+    const apiClient = createApiClient();
+    apiClient.apiConfig.config.supportsFolderManagement = false;
+    const manager = createManager(apiClient);
+
+    manager._showFolderContextMenu(10, 10, 'empty');
+
+    const item = document.querySelector('#sidebarFolderContextMenu [data-action="delete-folder"]');
+    expect(item.style.display).toBe('none');
+
+    manager._closeFolderContextMenu();
+  });
+});
+
@@ -10,11 +10,17 @@ class FakeMoveService:
    def __init__(self, result):
        self._result = result
        self.received_path = None
+        self.received_dry_run = None

    async def create_folder(self, folder_path):
        self.received_path = folder_path
        return self._result

+    async def delete_folder(self, folder_path, dry_run=False):
+        self.received_path = folder_path
+        self.received_dry_run = dry_run
+        return self._result
+

 class FakeRequest:
    def __init__(self, payload):
@@ -91,3 +97,118 @@ async def test_create_folder_invalid_json_body():
    assert response.status == 400
    payload = json.loads(response.text)
    assert payload["success"] is False
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_success():
+    handler, service = _make_handler(
+        {
+            "success": True,
+            "folder": "characters/anime",
+            "model_count": 0,
+            "restorable": True,
+        }
+    )
+
+    response = await handler.delete_folder(
+        FakeRequest({"folder_path": "/library/characters/anime"})
+    )
+
+    assert response.status == 200
+    payload = json.loads(response.text)
+    assert payload["success"] is True
+    assert payload["restorable"] is True
+    assert service.received_path == "/library/characters/anime"
+    assert service.received_dry_run is False
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_forwards_dry_run():
+    handler, service = _make_handler({"success": True, "dry_run": True})
+
+    response = await handler.delete_folder(
+        FakeRequest({"folder_path": "/library/empty", "dry_run": True})
+    )
+
+    assert response.status == 200
+    assert service.received_dry_run is True
+    assert json.loads(response.text)["dry_run"] is True
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_missing_path():
+    handler, service = _make_handler({"success": True})
+
+    response = await handler.delete_folder(FakeRequest({}))
+
+    assert response.status == 400
+    payload = json.loads(response.text)
+    assert payload["success"] is False
+    assert service.received_path is None
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_not_empty_maps_to_409():
+    handler, _service = _make_handler(
+        {
+            "success": False,
+            "code": "not_empty",
+            "error": "Folder still contains 2 model file(s); delete or move them first",
+            "manifest": {"model_count": 2},
+        }
+    )
+
+    response = await handler.delete_folder(
+        FakeRequest({"folder_path": "/library/full"})
+    )
+
+    assert response.status == 409
+    payload = json.loads(response.text)
+    assert payload["success"] is False
+    assert payload["code"] == "not_empty"
+    assert payload["manifest"]["model_count"] == 2
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_busy_maps_to_409():
+    handler, _service = _make_handler(
+        {"success": False, "code": "busy", "error": "staged delete pending"}
+    )
+
+    response = await handler.delete_folder(
+        FakeRequest({"folder_path": "/library/full"})
+    )
+
+    assert response.status == 409
+    assert json.loads(response.text)["code"] == "busy"
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_containment_failure_maps_to_400():
+    handler, _service = _make_handler(
+        {
+            "success": False,
+            "error": "Folder path '/etc/evil' is outside configured library directories",
+        }
+    )
+
+    response = await handler.delete_folder(FakeRequest({"folder_path": "/etc/evil"}))
+
+    assert response.status == 400
+    payload = json.loads(response.text)
+    assert payload["success"] is False
+    assert "outside configured library" in payload["error"]
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_invalid_json_body():
+    class BadJsonRequest:
+        async def json(self):
+            raise ValueError("bad json")
+
+    handler, _service = _make_handler({"success": True})
+
+    response = await handler.delete_folder(BadJsonRequest())
+
+    assert response.status == 400
+    assert json.loads(response.text)["success"] is False
@@ -14,6 +14,7 @@ class FakeScanner:
    def __init__(self, roots: List[Path]) -> None:
        self._roots = [str(root) for root in roots]
        self.known_folders: List[str] = []
+        self.removed_folders: List[str] = []

    def get_model_roots(self) -> List[str]:
        return list(self._roots)
@@ -21,6 +22,9 @@ class FakeScanner:
    async def add_known_folder(self, folder: str) -> None:
        self.known_folders.append(folder)

+    async def remove_known_folder(self, folder: str) -> None:
+        self.removed_folders.append(folder)
+

@pytest.mark.asyncio
 async def test_create_folder_creates_directory_and_registers_it(tmp_path: Path):
@@ -87,3 +91,183 @@ async def test_create_folder_requires_path(tmp_path: Path):
    result = await service.create_folder("")

    assert result["success"] is False
+
+
+def _make_nested(root: Path) -> Path:
+    target = root / "characters" / "anime"
+    target.mkdir(parents=True)
+    return target
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_removes_empty_directory_and_forgets_it(tmp_path: Path):
+    target = _make_nested(tmp_path)
+    scanner = FakeScanner([tmp_path])
+    service = ModelMoveService(scanner, "lora")
+
+    result = await service.delete_folder(str(target))
+
+    assert result["success"] is True
+    assert result["folder"] == "characters/anime"
+    assert result["model_count"] == 0
+    assert result["restorable"] is True
+    assert not target.exists()
+    assert scanner.removed_folders == ["characters/anime"]
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_reports_non_model_leftovers_as_not_restorable(tmp_path: Path):
+    target = _make_nested(tmp_path)
+    (target / "notes.txt").write_text("keep me?", encoding="utf-8")
+    (target / "nested").mkdir()
+    scanner = FakeScanner([tmp_path])
+    service = ModelMoveService(scanner, "lora")
+
+    result = await service.delete_folder(str(target))
+
+    assert result["success"] is True
+    assert result["file_count"] == 1
+    assert result["dir_count"] == 1
+    assert result["restorable"] is False
+    assert not target.exists()
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_refuses_when_models_live_below(tmp_path: Path):
+    target = _make_nested(tmp_path)
+    model_file = target / "model.safetensors"
+    model_file.write_text("weights", encoding="utf-8")
+    scanner = FakeScanner([tmp_path])
+    service = ModelMoveService(scanner, "lora")
+
+    result = await service.delete_folder(str(target))
+
+    assert result["success"] is False
+    assert result["code"] == "not_empty"
+    assert result["manifest"]["model_count"] == 1
+    assert target.exists()
+    assert model_file.exists()
+    assert scanner.removed_folders == []
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_refuses_while_a_staged_delete_is_pending(tmp_path: Path):
+    target = _make_nested(tmp_path)
+    (target / ".lm-pending-delete").mkdir()
+    scanner = FakeScanner([tmp_path])
+    service = ModelMoveService(scanner, "lora")
+
+    result = await service.delete_folder(str(target))
+
+    assert result["success"] is False
+    assert result["code"] == "busy"
+    assert target.exists()
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_refuses_the_library_root_itself(tmp_path: Path):
+    scanner = FakeScanner([tmp_path])
+    service = ModelMoveService(scanner, "lora")
+
+    result = await service.delete_folder(str(tmp_path))
+
+    assert result["success"] is False
+    assert "root" in result["error"].lower()
+    assert tmp_path.exists()
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_rejects_paths_outside_roots(tmp_path: Path):
+    root = tmp_path / "library"
+    root.mkdir()
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    scanner = FakeScanner([root])
+    service = ModelMoveService(scanner, "lora")
+
+    result = await service.delete_folder(str(outside))
+
+    assert result["success"] is False
+    assert "error" in result
+    assert outside.exists()
+    assert scanner.removed_folders == []
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_reports_missing_directory(tmp_path: Path):
+    scanner = FakeScanner([tmp_path])
+    service = ModelMoveService(scanner, "lora")
+
+    result = await service.delete_folder(str(tmp_path / "gone"))
+
+    assert result["success"] is False
+    assert "no longer exists" in result["error"]
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_requires_path(tmp_path: Path):
+    service = ModelMoveService(FakeScanner([tmp_path]), "lora")
+
+    result = await service.delete_folder("")
+
+    assert result["success"] is False
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_dry_run_reports_without_removing(tmp_path: Path):
+    target = _make_nested(tmp_path)
+    (target / "leftover.webp").write_text("preview", encoding="utf-8")
+    scanner = FakeScanner([tmp_path])
+    service = ModelMoveService(scanner, "lora")
+
+    result = await service.delete_folder(str(target), dry_run=True)
+
+    assert result["success"] is True
+    assert result["dry_run"] is True
+    assert result["file_count"] == 1
+    assert target.exists()
+    assert scanner.removed_folders == []
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_refuses_symlinked_directory(tmp_path: Path):
+    real = tmp_path / "real"
+    real.mkdir()
+    link = tmp_path / "link"
+    try:
+        link.symlink_to(real, target_is_directory=True)
+    except (OSError, NotImplementedError):  # pragma: no cover - platform guard
+        pytest.skip("symlinks are not supported on this platform")
+
+    scanner = FakeScanner([tmp_path])
+    service = ModelMoveService(scanner, "lora")
+
+    result = await service.delete_folder(str(link))
+
+    assert result["success"] is False
+    assert "symlink" in result["error"].lower()
+    assert link.is_symlink()
+    assert real.is_dir()
+
+
+@pytest.mark.asyncio
+async def test_delete_folder_counts_nested_symlinks_without_following_them(tmp_path: Path):
+    target = _make_nested(tmp_path)
+    real = tmp_path / "real"
+    real.mkdir()
+    (real / "model.safetensors").write_text("weights", encoding="utf-8")
+    try:
+        (target / "linked").symlink_to(real, target_is_directory=True)
+    except (OSError, NotImplementedError):  # pragma: no cover - platform guard
+        pytest.skip("symlinks are not supported on this platform")
+
+    scanner = FakeScanner([tmp_path])
+    service = ModelMoveService(scanner, "lora")
+
+    result = await service.delete_folder(str(target))
+
+    assert result["success"] is True
+    assert result["symlink_count"] == 1
+    # The linked model is not part of the subtree being deleted
+    assert result["model_count"] == 0
+    assert (real / "model.safetensors").exists()
@@ -1547,6 +1547,68 @@ async def test_add_known_folder_ignores_empty_input(tmp_path: Path):
    assert cache.all_folders == before


+@pytest.mark.asyncio
+async def test_remove_known_folder_drops_subtree_and_keeps_ancestors(tmp_path: Path):
+    _create_files(tmp_path)
+    scanner = DummyScanner(tmp_path)
+    await scanner._initialize_cache()
+    cache = await scanner.get_cached_data()
+    await scanner.add_known_folder("nested/deep/leaf")
+
+    await scanner.remove_known_folder("nested/deep")
+
+    assert "nested/deep" not in cache.all_folders
+    assert "nested/deep/leaf" not in cache.all_folders
+    # The ancestor directory still exists on disk in its own right
+    assert "nested" in cache.all_folders
+
+
+@pytest.mark.asyncio
+async def test_remove_known_folder_purges_stale_cache_entries(tmp_path: Path):
+    _, second, _ = _create_files(tmp_path)
+    scanner = DummyScanner(tmp_path)
+    await scanner._initialize_cache()
+    cache = await scanner.get_cached_data()
+    assert "nested" in cache.folders
+
+    await scanner.remove_known_folder("nested")
+
+    assert "nested" not in cache.all_folders
+    assert "nested" not in cache.folders
+    assert _normalize_path(second) not in {
+        item["file_path"] for item in cache.raw_data
+    }
+
+
+@pytest.mark.asyncio
+async def test_remove_known_folder_noop_without_recorded_folders(tmp_path: Path):
+    _create_files(tmp_path)
+    scanner = DummyScanner(tmp_path)
+    await scanner._initialize_cache()
+    cache = await scanner.get_cached_data()
+    cache.all_folders = None
+
+    # Legacy snapshot without recorded folders: nothing to prune, and the
+    # scheduled backfill walk rebuilds the list from disk.
+    await scanner.remove_known_folder("nested")
+
+    assert cache.all_folders is None
+
+
+@pytest.mark.asyncio
+async def test_remove_known_folder_ignores_empty_input(tmp_path: Path):
+    _create_files(tmp_path)
+    scanner = DummyScanner(tmp_path)
+    await scanner._initialize_cache()
+    cache = await scanner.get_cached_data()
+    before = list(cache.all_folders)
+
+    await scanner.remove_known_folder("")
+    await scanner.remove_known_folder("/")
+
+    assert cache.all_folders == before
+
+
@pytest.mark.asyncio
 async def test_get_all_folders_updated_after_move(tmp_path: Path):
    first, _, _ = _create_files(tmp_path)