diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/archive/entity/SharingArchive.java b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/archive/entity/SharingArchive.java
index 564107c2..599f4c4d 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/archive/entity/SharingArchive.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/archive/entity/SharingArchive.java
@@ -8,6 +8,7 @@
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import org.tuna.zoopzoop.backend.domain.archive.archive.enums.ArchiveType;
+import org.tuna.zoopzoop.backend.domain.archive.folder.entity.Folder;
 import org.tuna.zoopzoop.backend.domain.space.space.entity.Space;
 import org.tuna.zoopzoop.backend.global.jpa.entity.BaseEntity;
 
@@ -27,5 +28,9 @@ public class SharingArchive extends BaseEntity {
     public SharingArchive(Space space) {
         this.space = space;
         this.archive = new Archive(ArchiveType.SHARED);
+
+        // 🔧 default 폴더 자동 생성
+        Folder defaultFolder = new Folder("default");
+        this.archive.addFolder(defaultFolder);
     }
 }
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/controller/FolderController.java b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/controller/FolderController.java
index a9865c60..7142e46d 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/controller/FolderController.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/controller/FolderController.java
@@ -10,7 +10,7 @@
 import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
 import org.tuna.zoopzoop.backend.domain.archive.folder.dto.reqBodyForCreateFolder;
 import org.tuna.zoopzoop.backend.domain.archive.folder.dto.resBodyForCreateFolder;
-import org.tuna.zoopzoop.backend.domain.archive.folder.service.FolderService;
+import org.tuna.zoopzoop.backend.domain.archive.folder.service.PersonalArchiveFolderService;
 import org.tuna.zoopzoop.backend.domain.datasource.dto.FolderFilesDto;
 import org.tuna.zoopzoop.backend.domain.member.entity.Member;
 import org.tuna.zoopzoop.backend.global.rsData.RsData;
@@ -25,12 +25,10 @@
 @Tag(name = "ApiV1Folder", description = "개인 아카이브의 폴더 CRUD")
 public class FolderController {
 
-    private final FolderService folderService;
+    private final PersonalArchiveFolderService personalArchiveFolderService;
 
     /**
      * 내 PersonalArchive 안에 새 폴더 생성
-     * @param rq reqBodyForCreateFolder
-     * @return resBodyForCreateFolder
      */
     @Operation(summary = "폴더 생성", description = "내 PersonalArchive 안에 새 폴더를 생성합니다.")
     @PostMapping
@@ -39,41 +37,30 @@ public RsData<resBodyForCreateFolder> createFolder(
             @AuthenticationPrincipal CustomUserDetails userDetails
     ) {
         Member member = userDetails.getMember();
-        FolderResponse createFile = folderService.createFolderForPersonal(member.getId(), rq.folderName());
+        FolderResponse createFile = personalArchiveFolderService.createFolder(member.getId(), rq.folderName());
         resBodyForCreateFolder rs = new resBodyForCreateFolder(createFile.folderName(), createFile.folderId());
 
-        return new RsData<>(
-                "200",
-                rq.folderName() + " 폴더가 생성됐습니다.",
-                rs
-        );
+        return new RsData<>("200",rq.folderName() + " 폴더가 생성됐습니다.", rs);
     }
 
     /**
      * 내 PersonalArchive 안의 folder 삭제
-     * @param folderId  삭제할 folderId
      */
     @DeleteMapping("/{folderId}")
-    public ResponseEntity<Map<String, Object>> deleteFolder(
+    public ResponseEntity<RsData<?>> deleteFolder(
             @PathVariable Integer folderId,
             @AuthenticationPrincipal CustomUserDetails userDetails
     ) {
-        if (folderId == 0) {
-            var body = new java.util.HashMap<String, Object>();
-            body.put("status", 409);
-            body.put("msg", "default 폴더는 삭제할 수 없습니다.");
-            body.put("data", null);
-            return ResponseEntity.badRequest().body(body);
-        }
+        if (folderId == 0)
+            throw new IllegalArgumentException("default 폴더는 삭제할 수 없습니다.");
+
 
         Member member = userDetails.getMember();
-        String deletedFolderName = folderService.deleteFolder(member.getId(), folderId);
+        String deletedFolderName = personalArchiveFolderService.deleteFolder(member.getId(), folderId);
 
-        var body = new java.util.HashMap<String, Object>();
-        body.put("status", 200);
-        body.put("msg", deletedFolderName + " 폴더가 삭제됐습니다.");
-        body.put("data", null);
-        return ResponseEntity.ok(body);
+        return ResponseEntity.ok(
+                new RsData<>("200", deletedFolderName + " 폴더가 삭제됐습니다.", null)
+        );
     }
 
     /**
@@ -82,28 +69,23 @@ public ResponseEntity<Map<String, Object>> deleteFolder(
      * @param body  수정할 폴더 값
      */
     @PatchMapping("/{folderId}")
-    public ResponseEntity<Map<String, Object>> updateFolderName(
+    public ResponseEntity<RsData<Map<String, String>>> updateFolderName(
             @PathVariable Integer folderId,
             @RequestBody Map<String, String> body,
             @AuthenticationPrincipal CustomUserDetails userDetails
     ) {
-        if (folderId == 0) {
-            var res = new java.util.HashMap<String, Object>();
-            res.put("status", 400);
-            res.put("msg", "default 폴더는 이름을 변경할 수 없습니다.");
-            res.put("data", null);
-            return ResponseEntity.badRequest().body(res);
-        }
+        if (folderId == 0)
+            throw new IllegalArgumentException("default 폴더는 이름을 변경할 수 없습니다.");
+
 
         Member member = userDetails.getMember();
         String newName = body.get("folderName");
-        String updatedName = folderService.updateFolderName(member.getId(), folderId, newName);
+        String updatedName = personalArchiveFolderService.updateFolderName(member.getId(), folderId, newName);
 
-        return ResponseEntity.ok(java.util.Map.of(
-                "status", 200,
-                "msg", "폴더 이름이 " + updatedName + " 으로 변경됐습니다.",
-                "data", java.util.Map.of("folderName", updatedName)
-        ));
+        return ResponseEntity.ok(
+                new RsData<>("200", "폴더 이름이 " + updatedName + " 으로 변경됐습니다.",
+                        Map.of("folderName", updatedName))
+        );
     }
 
     /**
@@ -112,18 +94,14 @@ public ResponseEntity<Map<String, Object>> updateFolderName(
      */
     @Operation(summary = "폴더 이름 조회", description = "내 PersonalArchive 안에 이름을 전부 조회합니다.")
     @GetMapping
-    public ResponseEntity<?> getFolders(
+    public ResponseEntity<RsData<List<FolderResponse>>> getFolders(
             @AuthenticationPrincipal CustomUserDetails userDetails
     ) {
         Member member = userDetails.getMember();
-        List<FolderResponse> folders = folderService.getFoldersForPersonal(member.getId());
+        List<FolderResponse> folders = personalArchiveFolderService.getFolders(member.getId());
 
         return ResponseEntity.ok(
-                Map.of(
-                        "status", 200,
-                        "msg", "개인 아카이브의 폴더 목록을 불러왔습니다.",
-                        "data", Map.of("folders", folders)
-                )
+                new RsData<>("200", "개인 아카이브의 폴더 목록을 불러왔습니다.", folders)
         );
     }
 
@@ -138,22 +116,14 @@ public ResponseEntity<?> getFilesInFolder(
         int memberId = userDetails.getMember().getId();
 
         Integer targetFolderId = (folderId == 0)
-                ? folderService.getDefaultFolderId(memberId)
+                ? personalArchiveFolderService.getDefaultFolderId(memberId)
                 : folderId;
 
-        FolderFilesDto rs = folderService.getFilesInFolderForPersonal(memberId, targetFolderId);
-
-        return ResponseEntity.ok(Map.of(
-                "status", 200,
-                "msg", folderId == 0 ? "기본 폴더의 파일 목록을 불러왔습니다." : "해당 폴더의 파일 목록을 불러왔습니다.",
-                "data", Map.of(
-                        "folder", Map.of(
-                                "folderId", rs.folderId(),
-                                "folderName", rs.folderName()
-                        ),
-                        "files", rs.files()
-                )
-        ));
+        FolderFilesDto rs = personalArchiveFolderService.getFilesInFolder(memberId, targetFolderId);
+
+        return ResponseEntity.ok(
+                new RsData<>("200","해당 폴더의 파일 목록을 불러왔습니다.", rs)
+        );
     }
 
 }
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/dto/FolderResponse.java b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/dto/FolderResponse.java
index e6063343..78d38b04 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/dto/FolderResponse.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/dto/FolderResponse.java
@@ -1,7 +1,6 @@
 package org.tuna.zoopzoop.backend.domain.archive.folder.dto;
 
 public record FolderResponse(
-        int folderId,
-        String folderName
-
+        String folderName,
+        int folderId
 ) {}
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/repository/FolderRepository.java b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/repository/FolderRepository.java
index cc2215f4..91b68ca7 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/repository/FolderRepository.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/repository/FolderRepository.java
@@ -72,4 +72,17 @@ Optional<Folder> findByIdAndMemberId(@Param("folderId") Integer folderId,
         where pa.member.id = :memberId and f.isDefault = true
     """)
     Optional<Folder> findDefaultByMemberId(@Param("memberId") Integer memberId);
+
+    Optional<Folder> findByIdAndArchiveId(Integer folderId, Integer archiveId);
+
+    @Query("""
+        select f.name
+        from Folder f
+        where f.archive.id = :archiveId
+          and f.name = :name
+          and f.id <> :excludeFolderId
+    """)
+    List<String> existsNameInArchiveExceptSelf(@Param("archiveId") Integer archiveId,
+                                               @Param("name") String name,
+                                               @Param("excludeFolderId") Integer excludeFolderId);
 }
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/FolderService.java b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/FolderService.java
index 6250d622..b5a39118 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/FolderService.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/FolderService.java
@@ -6,8 +6,6 @@
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.tuna.zoopzoop.backend.domain.archive.archive.entity.Archive;
-import org.tuna.zoopzoop.backend.domain.archive.archive.entity.PersonalArchive;
-import org.tuna.zoopzoop.backend.domain.archive.archive.repository.PersonalArchiveRepository;
 import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
 import org.tuna.zoopzoop.backend.domain.archive.folder.entity.Folder;
 import org.tuna.zoopzoop.backend.domain.archive.folder.repository.FolderRepository;
@@ -16,8 +14,6 @@
 import org.tuna.zoopzoop.backend.domain.datasource.entity.DataSource;
 import org.tuna.zoopzoop.backend.domain.datasource.entity.Tag;
 import org.tuna.zoopzoop.backend.domain.datasource.repository.DataSourceRepository;
-import org.tuna.zoopzoop.backend.domain.member.entity.Member;
-import org.tuna.zoopzoop.backend.domain.member.repository.MemberRepository;
 
 import java.time.LocalDate;
 import java.util.HashSet;
@@ -29,32 +25,19 @@
 @RequiredArgsConstructor
 public class FolderService {
 
-    private final MemberRepository memberRepository;
-    private final PersonalArchiveRepository personalArchiveRepository;
     private final FolderRepository folderRepository;
     private final DataSourceRepository dataSourceRepository;
 
-    /**
-     * 현재 로그인 사용자의 PersonalArchive에 폴더 생성
-     * - 폴더명 중복 시 "(n)" 추가
-     * - 동시성 충돌 시(더블 클릭, 브라우저 재전송) 재시도
-     */
+    // ===== 생성 =====
     @Transactional
-    public FolderResponse createFolderForPersonal(Integer currentMemberId, String folderName) {
+    public FolderResponse createFolder(Archive archive, String folderName) {
+        if (archive == null) throw new NoResultException("아카이브가 존재하지 않습니다.");
         if (folderName == null || folderName.trim().isEmpty())
             throw new IllegalArgumentException("폴더 이름은 비어 있을 수 없습니다.");
 
-        Member member = memberRepository.findById(currentMemberId)
-                .orElseThrow(() -> new NoResultException("멤버를 찾을 수 없습니다."));
-
-        Archive archive = personalArchiveRepository.findByMemberId(member.getId())
-                .map(PersonalArchive::getArchive)
-                .orElseThrow(() -> new NoResultException("개인 아카이브가 없습니다."));
-
         final String requested = folderName.trim();
-
-        // 동시성 춛돌시 2번 재시도
         String unique = generateUniqueFolderName(archive.getId(), requested);
+
         for (int attempt = 0; attempt < 2; attempt++) {
             try {
                 Folder folder = new Folder();
@@ -63,7 +46,7 @@ public FolderResponse createFolderForPersonal(Integer currentMemberId, String fo
                 folder.setDefault(false);
 
                 Folder saved = folderRepository.save(folder);
-                return new FolderResponse( saved.getId(), saved.getName());
+                return new FolderResponse(saved.getName(), saved.getId());
             } catch (DataIntegrityViolationException e) {
                 unique = generateUniqueFolderName(archive.getId(), requested);
             }
@@ -71,64 +54,20 @@ public FolderResponse createFolderForPersonal(Integer currentMemberId, String fo
         throw new IllegalStateException("동시성 충돌로 폴더 생성에 실패했습니다. 잠시 후 다시 시도해주세요.");
     }
 
-    private static final Pattern SUFFIX_PATTERN = Pattern.compile("^(.*?)(?: \\((\\d+)\\))?$");
-
-    /**
-     * 기존 file 명과 같지 않은 최솟값의 이름 생성
-     * “폴더명”, "폴더명 (1)"→ "폴더명 (2)"
-     * "폴더명", "폴더명 (2)" -> "폴더명 (1)"
-     */
-    private String generateUniqueFolderName(Integer archiveId, String requested) {
-        NameParts nameParts = NameParts.split(requested);
-
-        // 중복 폴더명 탐색
-        String file = nameParts.base();
-        String fileEnd = file + "\uffff";
-
-        List<String> existing = folderRepository.findNamesForConflictCheck(archiveId, file, fileEnd);
-
-        return pickNextAvailable(file, existing);
-    }
-
-    /**
-     * 이미 존재하는 이름들 중 가장 작은 비어 있는 번호 반환
-     */
-    private static String pickNextAvailable(String file, List<String> existing) {
-        boolean baseUsed = false;
-        Set<Integer> used = new HashSet<>();
-        Pattern p = Pattern.compile("^" + Pattern.quote(file) + "(?: \\((\\d+)\\))?$");
-
-        for (String s : existing) {
-            var m = p.matcher(s);
-            if (m.matches()) {
-                if (m.group(1) == null) baseUsed = true;
-                else used.add(Integer.parseInt(m.group(1)));
-            }
-        }
-        if (!baseUsed) return file;
-        for (int k = 1; k <= used.size() + 1; k++) {
-            if (!used.contains(k)) return file + " (" + k + ")";
-        }
-        return file + " (" + (used.size() + 1) + ")"; // fallback
-    }
-
-    /**
-     *  folderId에 해당하는 폴더 영구 삭제
-     */
+    // ===== 삭제 =====
     @Transactional
-    public String deleteFolder(Integer currentId, Integer folderId) {
-        // 소유한 폴더인지 확인
-        Folder folder = folderRepository.findByIdAndMemberId(folderId, currentId)
+    public String deleteFolder(Archive archive, Integer folderId) {
+        Folder folder = folderRepository.findByIdAndArchiveId(folderId, archive.getId())
                 .orElseThrow(() -> new NoResultException("존재하지 않는 폴더입니다."));
 
-        if (folder.isDefault()) {
+        if (folder.isDefault())
             throw new IllegalArgumentException("default 폴더는 삭제할 수 없습니다.");
-        }
 
-        Folder defaultFolder = folderRepository.findDefaultByMemberId(currentId)
+        // 기본 폴더 확보 (같은 archive)
+        Folder defaultFolder = folderRepository.findByArchiveIdAndIsDefaultTrue(archive.getId())
                 .orElseThrow(() -> new IllegalStateException("default 폴더가 존재하지 않습니다."));
 
-        // 폴더 내 자료들을 Default로 이관 + soft delete
+        // 폴더 내 자료 이관 + soft delete(네 정책 유지)
         List<DataSource> dataSources = dataSourceRepository.findAllByFolderId(folderId);
         LocalDate now = LocalDate.now();
         for (DataSource ds : dataSources) {
@@ -139,71 +78,56 @@ public String deleteFolder(Integer currentId, Integer folderId) {
 
         String name = folder.getName();
         folderRepository.delete(folder);
-
         return name;
     }
 
-    /**
-     *  folderId에 해당하는 이름 변경
-     */
+    // ===== 이름 변경 =====
     @Transactional
-    public String updateFolderName(Integer currentId, Integer folderId, String newName) {
-        Folder folder = folderRepository.findByIdAndMemberId(folderId, currentId)
+    public String updateFolderName(Archive archive, Integer folderId, String newName) {
+        if (newName == null || newName.trim().isEmpty())
+            throw new IllegalArgumentException("폴더 이름은 비어 있을 수 없습니다.");
+
+        Folder folder = folderRepository.findByIdAndArchiveId(folderId, archive.getId())
                 .orElseThrow(() -> new NoResultException("존재하지 않는 폴더입니다."));
 
-        // 같은 아카이브 내에서 중복 폴더 이름 확인
-        List<String> existingNames = folderRepository.findNamesForConflictCheck(
-                folder.getArchive().getId(),
-                newName,
-                folder.getName() // 자기 자신은 제외
-        );
+        if (folder.isDefault())
+            throw new IllegalArgumentException("default 폴더는 이름을 변경할 수 없습니다.");
 
-        if (!existingNames.isEmpty()) {
+        // 같은 Archive 내 동명 검사 (자기 자신 제외)
+        List<String> conflict = folderRepository.existsNameInArchiveExceptSelf(
+                archive.getId(), newName.trim(), folder.getId());
+        if (!conflict.isEmpty()) {
             throw new IllegalArgumentException("이미 존재하는 폴더명입니다.");
         }
 
-        folder.setName(newName);
+        folder.setName(newName.trim());
         folderRepository.save(folder);
-        return newName;
+        return folder.getName();
     }
 
-    /**
-     * Personal Archive의 폴더명 전부 조회
-     * @param memberId  Personal Archive 회원 Id
-     */
+    // ===== 목록 조회 =====
     @Transactional(readOnly = true)
-    public List<FolderResponse> getFoldersForPersonal(Integer memberId) {
-        PersonalArchive personalArchive = personalArchiveRepository.findByMemberId(memberId)
-                .orElseThrow(() -> new NoResultException("개인 아카이브가 존재하지 않습니다."));
-        Archive archive = personalArchive.getArchive();
-
+    public List<FolderResponse> getFolders(Archive archive) {
         return folderRepository.findByArchive(archive).stream()
-                .map(folder -> new FolderResponse(folder.getId(), folder.getName()))
+                .map(f -> new FolderResponse(f.getName(), f.getId()))
                 .toList();
     }
 
-    /**
-     * 폴더 하위 파일(datasource) 조회
-     * @param memberId   Personal Archive 회원 Id
-     * @param folderId   조회할 folder Id
-     */
+    // ===== 폴더 내 파일 조회 =====
     @Transactional(readOnly = true)
-    public FolderFilesDto getFilesInFolderForPersonal(Integer memberId, Integer folderId) {
-        Folder folder = folderRepository.findByIdAndMemberId(folderId, memberId)
+    public FolderFilesDto getFilesInFolder(Archive archive, Integer folderId) {
+        Folder folder = folderRepository.findByIdAndArchiveId(folderId, archive.getId())
                 .orElseThrow(() -> new NoResultException("존재하지 않는 폴더입니다."));
 
         var files = dataSourceRepository.findAllByFolder(folder).stream()
                 .map(ds -> new FileSummary(
                         ds.getId(),
                         ds.getTitle(),
-                        ds.getDataCreatedDate(),      // LocalDate
+                        ds.getDataCreatedDate(),
                         ds.getSummary(),
                         ds.getSourceUrl(),
                         ds.getImageUrl(),
-                        ds.getTags() == null ? List.of()
-                                : ds.getTags().stream()
-                                .map(Tag::getTagName)
-                                .toList(),
+                        ds.getTags() == null ? List.of() : ds.getTags().stream().map(Tag::getTagName).toList(),
                         ds.getCategory() == null ? null : ds.getCategory().name()
                 ))
                 .toList();
@@ -211,19 +135,43 @@ public FolderFilesDto getFilesInFolderForPersonal(Integer memberId, Integer fold
         return new FolderFilesDto(folder.getId(), folder.getName(), files);
     }
 
+    // ===== 기본 폴더 ID 조회 (Archive 스코프) =====
+    @Transactional(readOnly = true)
+    public Integer getDefaultFolderId(Archive archive) {
+        return folderRepository.findByArchiveIdAndIsDefaultTrue(archive.getId())
+                .orElseThrow(() -> new NoResultException("default 폴더를 찾을 수 없습니다."))
+                .getId();
+    }
 
-    public Integer getDefaultFolderId(int memberId) {
-        Folder folder = folderRepository.findDefaultFolderByMemberId(memberId)
-                .orElseThrow(() -> new NoResultException("default 폴더를 찾을 수 없습니다."));
-        return folder.getId();
+    // ===== 이름 충돌 유틸 =====
+    private static final Pattern SUFFIX_PATTERN = Pattern.compile("^(.*?)(?: \\((\\d+)\\))?$");
 
+    private String generateUniqueFolderName(Integer archiveId, String requested) {
+        NameParts nameParts = NameParts.split(requested);
+        String file = nameParts.base();
+        String fileEnd = file + "\uffff";
+        List<String> existing = folderRepository.findNamesForConflictCheck(archiveId, file, fileEnd);
+        return pickNextAvailable(file, existing);
+    }
+
+    private static String pickNextAvailable(String file, List<String> existing) {
+        boolean baseUsed = false;
+        Set<Integer> used = new HashSet<>();
+        Pattern p = Pattern.compile("^" + Pattern.quote(file) + "(?: \\((\\d+)\\))?$");
+        for (String s : existing) {
+            var m = p.matcher(s);
+            if (m.matches()) {
+                if (m.group(1) == null) baseUsed = true;
+                else used.add(Integer.parseInt(m.group(1)));
+            }
+        }
+        if (!baseUsed) return file;
+        for (int k = 1; k <= used.size() + 1; k++) {
+            if (!used.contains(k)) return file + " (" + k + ")";
+        }
+        return file + " (" + (used.size() + 1) + ")";
     }
 
-    /**
-     * 입력된 폴더명을 (폴더명, 숫자)로 분리하는 유틸 클래스
-     * “폴더명” → (”폴더명”, null)
-     * “폴더명(3)” → (”폴더명”, 3)
-     */
     private record NameParts(String base, Integer num) {
         static NameParts split(String name) {
             var m = SUFFIX_PATTERN.matcher(name.trim());
@@ -236,3 +184,4 @@ static NameParts split(String name) {
         }
     }
 }
+
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/PersonalArchiveFolderService.java b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/PersonalArchiveFolderService.java
new file mode 100644
index 00000000..73edaa7d
--- /dev/null
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/PersonalArchiveFolderService.java
@@ -0,0 +1,69 @@
+package org.tuna.zoopzoop.backend.domain.archive.folder.service;
+
+import jakarta.persistence.NoResultException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.tuna.zoopzoop.backend.domain.archive.archive.entity.Archive;
+import org.tuna.zoopzoop.backend.domain.archive.archive.entity.PersonalArchive;
+import org.tuna.zoopzoop.backend.domain.archive.archive.repository.PersonalArchiveRepository;
+import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
+import org.tuna.zoopzoop.backend.domain.archive.folder.entity.Folder;
+import org.tuna.zoopzoop.backend.domain.archive.folder.repository.FolderRepository;
+import org.tuna.zoopzoop.backend.domain.datasource.dto.FolderFilesDto;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class PersonalArchiveFolderService {
+
+    private final PersonalArchiveRepository personalArchiveRepository;
+    private final FolderRepository folderRepository;
+    private final FolderService folderService;
+
+    @Transactional
+    public FolderResponse createFolder(Integer memberId, String folderName) {
+        Archive archive = personalArchiveRepository.findByMemberId(memberId)
+                .map(PersonalArchive::getArchive)
+                .orElseThrow(() -> new NoResultException("개인 아카이브가 없습니다."));
+        return folderService.createFolder(archive, folderName);
+    }
+
+    @Transactional
+    public String deleteFolder(Integer memberId, Integer folderId) {
+        // 개인 전용 “소유 확인” 쿼리로 빠르게 가드
+        Folder folder = folderRepository.findByIdAndMemberId(folderId, memberId)
+                .orElseThrow(() -> new NoResultException("존재하지 않는 폴더입니다."));
+        return folderService.deleteFolder(folder.getArchive(), folderId);
+    }
+
+    @Transactional
+    public String updateFolderName(Integer memberId, Integer folderId, String newName) {
+        Folder folder = folderRepository.findByIdAndMemberId(folderId, memberId)
+                .orElseThrow(() -> new NoResultException("존재하지 않는 폴더입니다."));
+        return folderService.updateFolderName(folder.getArchive(), folderId, newName);
+    }
+
+    @Transactional(readOnly = true)
+    public List<FolderResponse> getFolders(Integer memberId) {
+        Archive archive = personalArchiveRepository.findByMemberId(memberId)
+                .map(PersonalArchive::getArchive)
+                .orElseThrow(() -> new NoResultException("개인 아카이브가 존재하지 않습니다."));
+        return folderService.getFolders(archive);
+    }
+
+    @Transactional(readOnly = true)
+    public FolderFilesDto getFilesInFolder(Integer memberId, Integer folderId) {
+        Folder folder = folderRepository.findByIdAndMemberId(folderId, memberId)
+                .orElseThrow(() -> new NoResultException("존재하지 않는 폴더입니다."));
+        return folderService.getFilesInFolder(folder.getArchive(), folderId);
+    }
+
+    @Transactional(readOnly = true)
+    public Integer getDefaultFolderId(Integer memberId) {
+        Folder folder = folderRepository.findDefaultFolderByMemberId(memberId)
+                .orElseThrow(() -> new NoResultException("default 폴더를 찾을 수 없습니다."));
+        return folder.getId();
+    }
+}
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/controller/DatasourceController.java b/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/controller/DatasourceController.java
index f24466fe..9443e2f8 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/controller/DatasourceController.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/controller/DatasourceController.java
@@ -231,6 +231,7 @@ public ResponseEntity<?> search(
             @RequestParam(required = false) String title,
             @RequestParam(required = false) String summary,
             @RequestParam(required = false) String category,
+            @RequestParam(required = false) String keyword,
             @RequestParam(required = false) Integer folderId,
             @RequestParam(required = false) String folderName,
             @RequestParam(required = false, defaultValue = "true") Boolean isActive,
@@ -247,6 +248,7 @@ public ResponseEntity<?> search(
                 .folderId(folderId)
                 .folderName(folderName)
                 .isActive(isActive)
+                .keyword(keyword)
                 .build();
 
         Page<DataSourceSearchItem> page = dataSourceService.search(memberId, cond, pageable);
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/dto/DataSourceSearchCondition.java b/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/dto/DataSourceSearchCondition.java
index 19778980..f05bb2ab 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/dto/DataSourceSearchCondition.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/dto/DataSourceSearchCondition.java
@@ -12,4 +12,5 @@ public class DataSourceSearchCondition {
     private final Integer folderId;
     private final String folderName;
     private final Boolean isActive;
+    private final String keyword;
 }
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/dto/DataSourceSearchItem.java b/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/dto/DataSourceSearchItem.java
index 86a1dc03..d1ef68c0 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/dto/DataSourceSearchItem.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/dto/DataSourceSearchItem.java
@@ -13,6 +13,7 @@ public class DataSourceSearchItem {
     private String title;
     private LocalDate dataCreatedDate;
     private String summary;
+    private String source;
     private String sourceUrl;
     private String imageUrl;
     private List<String> tags;
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/repository/DataSourceQRepositoryImpl.java b/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/repository/DataSourceQRepositoryImpl.java
index 5bf745bc..f2d05960 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/repository/DataSourceQRepositoryImpl.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/repository/DataSourceQRepositoryImpl.java
@@ -20,6 +20,8 @@
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static org.springframework.util.StringUtils.hasText;
+
 @Repository
 @RequiredArgsConstructor
 public class DataSourceQRepositoryImpl implements DataSourceQRepository {
@@ -52,6 +54,15 @@ public Page<DataSourceSearchItem> search(Integer memberId, DataSourceSearchCondi
         if (cond.getCategory() != null && !cond.getCategory().isBlank()) {
             where.and(ds.category.stringValue().containsIgnoreCase(cond.getCategory()));
         }
+        if (hasText(cond.getKeyword())) {
+            String kw = cond.getKeyword();
+            where.and(
+                    ds.title.containsIgnoreCase(kw)
+                            .or(ds.summary.containsIgnoreCase(kw))
+                            .or(ds.category.stringValue().containsIgnoreCase(kw))
+            );
+        }
+
         if (cond.getFolderName() != null && !cond.getFolderName().isBlank()) {
             where.and(ds.folder.name.eq(cond.getFolderName()));
         }
@@ -72,7 +83,7 @@ public Page<DataSourceSearchItem> search(Integer memberId, DataSourceSearchCondi
 
         // content
         JPAQuery<Tuple> contentQuery = queryFactory
-                .select(ds.id, ds.title, ds.dataCreatedDate, ds.summary, ds.sourceUrl, ds.imageUrl, ds.category)
+                .select(ds.id, ds.title, ds.dataCreatedDate, ds.summary, ds.source, ds.sourceUrl, ds.imageUrl, ds.category)
                 .from(ds)
                 .join(ds.folder, folder)
                 .join(pa).on(pa.archive.eq(folder.archive))
@@ -110,13 +121,13 @@ public Page<DataSourceSearchItem> search(Integer memberId, DataSourceSearchCondi
                         Collectors.mapping(row -> row.get(tag.tagName), Collectors.toList())
                 ));
 
-        // map to DTO
         List<DataSourceSearchItem> content = tuples.stream()
                 .map(row -> new DataSourceSearchItem(
                         row.get(ds.id),
                         row.get(ds.title),
                         row.get(ds.dataCreatedDate),
                         row.get(ds.summary),
+                        row.get(ds.source),
                         row.get(ds.sourceUrl),
                         row.get(ds.imageUrl),
                         tagsById.getOrDefault(row.get(ds.id), List.of()),
@@ -140,7 +151,7 @@ private List<OrderSpecifier<?>> toOrderSpecifiers(Sort sort) {
             switch (o.getProperty()) {
                 case "title" ->
                         specs.add(new OrderSpecifier<>(dir, root.getString("title")));
-                case "createdAt" -> // 요청 키
+                case "createdAt" ->
                         specs.add(new OrderSpecifier<>(dir, root.getDate("dataCreatedDate", java.time.LocalDate.class)));
                 default -> { }
             }
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/service/DataSourceService.java b/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/service/DataSourceService.java
index 3c30ef6b..00648e93 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/service/DataSourceService.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/datasource/service/DataSourceService.java
@@ -12,7 +12,7 @@
 import org.tuna.zoopzoop.backend.domain.archive.archive.repository.PersonalArchiveRepository;
 import org.tuna.zoopzoop.backend.domain.archive.folder.entity.Folder;
 import org.tuna.zoopzoop.backend.domain.archive.folder.repository.FolderRepository;
-import org.tuna.zoopzoop.backend.domain.archive.folder.service.FolderService;
+import org.tuna.zoopzoop.backend.domain.archive.folder.service.PersonalArchiveFolderService;
 import org.tuna.zoopzoop.backend.domain.datasource.dataprocessor.service.DataProcessorService;
 import org.tuna.zoopzoop.backend.domain.datasource.dto.DataSourceDto;
 import org.tuna.zoopzoop.backend.domain.datasource.dto.DataSourceSearchCondition;
@@ -34,7 +34,7 @@
 public class DataSourceService {
     private final DataSourceRepository dataSourceRepository;
     private final FolderRepository folderRepository;
-    private final FolderService folderService;
+    private final PersonalArchiveFolderService folderService;
     private final PersonalArchiveRepository personalArchiveRepository;
     private final TagRepository tagRepository;
     private final DataProcessorService dataProcessorService;
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/news/service/NewsService.java b/src/main/java/org/tuna/zoopzoop/backend/domain/news/service/NewsService.java
index 4ef7b5d2..b6b89221 100644
--- a/src/main/java/org/tuna/zoopzoop/backend/domain/news/service/NewsService.java
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/news/service/NewsService.java
@@ -2,7 +2,7 @@
 
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
-import org.tuna.zoopzoop.backend.domain.archive.folder.service.FolderService;
+import org.tuna.zoopzoop.backend.domain.archive.folder.service.PersonalArchiveFolderService;
 import org.tuna.zoopzoop.backend.domain.datasource.dto.FileSummary;
 import org.tuna.zoopzoop.backend.domain.datasource.dto.FolderFilesDto;
 
@@ -14,10 +14,10 @@
 @Service
 @RequiredArgsConstructor
 public class NewsService {
-    private final FolderService folderService;
+    private final PersonalArchiveFolderService folderService;
 
     public List<String> getTagFrequencyFromFiles(Integer memberId, Integer folderId) {
-        FolderFilesDto folderFilesDto = folderService.getFilesInFolderForPersonal(memberId, folderId);
+        FolderFilesDto folderFilesDto = folderService.getFilesInFolder(memberId, folderId);
 
         List<FileSummary> files = folderFilesDto.files();
 
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/space/archive/controller/SpaceArchiveFolderController.java b/src/main/java/org/tuna/zoopzoop/backend/domain/space/archive/controller/SpaceArchiveFolderController.java
new file mode 100644
index 00000000..d82808ae
--- /dev/null
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/space/archive/controller/SpaceArchiveFolderController.java
@@ -0,0 +1,126 @@
+package org.tuna.zoopzoop.backend.domain.space.archive.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
+import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
+import org.tuna.zoopzoop.backend.domain.archive.folder.dto.reqBodyForCreateFolder;
+import org.tuna.zoopzoop.backend.domain.archive.folder.dto.resBodyForCreateFolder;
+import org.tuna.zoopzoop.backend.domain.datasource.dto.FolderFilesDto;
+import org.tuna.zoopzoop.backend.domain.member.entity.Member;
+import org.tuna.zoopzoop.backend.domain.space.archive.service.SpaceArchiveFolderService;
+import org.tuna.zoopzoop.backend.global.rsData.RsData;
+import org.tuna.zoopzoop.backend.global.security.jwt.CustomUserDetails;
+
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/v1/spaces/{spaceId}/archive/folder")
+@RequiredArgsConstructor
+@Tag(name = "SpaceArchiveFolder", description = "공유 아카이브의 폴더 CRUD")
+public class SpaceArchiveFolderController {
+
+    private final SpaceArchiveFolderService spaceArchiveFolderService;
+
+    /**
+     * 공유 아카이브 안에 새 폴더 생성
+     */
+    @Operation(summary = "폴더 생성", description = "해당 스페이스의 공유 아카이브에 새 폴더를 생성합니다.")
+    @PostMapping
+    public RsData<resBodyForCreateFolder> createFolder(
+            @PathVariable Integer spaceId,
+            @Valid @RequestBody reqBodyForCreateFolder rq,
+            @AuthenticationPrincipal CustomUserDetails userDetails
+    ) {
+        Member requester = userDetails.getMember();
+        FolderResponse fr = spaceArchiveFolderService.createFolder(spaceId, requester, rq.folderName());
+        resBodyForCreateFolder rs = new resBodyForCreateFolder(fr.folderName(), fr.folderId());
+        return new RsData<>(
+                "200",
+                rq.folderName() + " 폴더가 생성되었습니다.",
+                rs
+        );
+    }
+
+    /**
+     * 공유 아카이브의 폴더 삭제
+     */
+    @Operation(summary = "폴더 삭제", description = "해당 스페이스의 공유 아카이브에서 폴더를 삭제합니다.")
+    @DeleteMapping("/{folderId}")
+    public ResponseEntity<RsData<?>> deleteFolder(
+            @PathVariable Integer spaceId,
+            @PathVariable Integer folderId,
+            @AuthenticationPrincipal CustomUserDetails userDetails
+    ) {
+        if (folderId == 0)
+            throw new IllegalArgumentException("default 폴더는 삭제할 수 없습니다.");
+
+
+        String deletedFolderName = spaceArchiveFolderService.deleteFolder(spaceId, userDetails.getMember(), folderId);
+        return ResponseEntity.ok().body(
+                new RsData<>("200", deletedFolderName + " 폴더가 삭제됐습니다.", null)
+        );
+    }
+
+    /**
+     * 공유 아카이브의 폴더 이름 수정
+     */
+    @Operation(summary = "폴더 이름 수정", description = "해당 스페이스의 공유 아카이브에서 폴더 이름을 변경합니다.")
+    @PatchMapping("/{folderId}")
+    public ResponseEntity<RsData<?>> updateFolderName(
+            @PathVariable Integer spaceId,
+            @PathVariable Integer folderId,
+            @RequestBody Map<String, String> body,
+            @AuthenticationPrincipal CustomUserDetails principal
+    ) {
+        if (folderId == 0)
+            throw new IllegalArgumentException("default 폴더는 이름을 변경할 수 없습니다.");
+
+        String updatename = spaceArchiveFolderService.updateFolderName(spaceId, principal.getMember(), folderId, body.get("folderName"));
+        return ResponseEntity.ok().body(
+                new RsData<>("200", "폴더 이름이 " + updatename + "(으)로 변경됐습니다.", new FolderResponse(updatename, folderId))
+        );
+    }
+
+    /**
+     * 공유 아카이브의 폴더 목록 조회
+     */
+    @Operation(summary = "폴더 이름 조회", description = "해당 스페이스의 공유 아카이브 폴더 목록을 조회합니다.")
+    @GetMapping
+    public ResponseEntity<RsData<List<FolderResponse>>> listFolders(
+            @PathVariable Integer spaceId,
+            @AuthenticationPrincipal CustomUserDetails userDetails
+    ) {
+        List<FolderResponse> folders = spaceArchiveFolderService.getFolders(spaceId, userDetails.getMember());
+        return ResponseEntity.ok().body(
+                new RsData<>("200", "공유 아카이브의 폴더 목록이 조회되었습니다.", folders)
+        );
+    }
+
+    /**
+     * 공유 아카이브의 특정 폴더 내 파일 목록 조회
+     */
+    @Operation(summary = "폴더 내 파일 조회", description = "해당 스페이스의 공유 아카이브에서 특정 폴더 내 파일 목록을 조회합니다.")
+    @GetMapping("/{folderId}/files")
+    public ResponseEntity<RsData<FolderFilesDto>> filesInFolder(
+            @PathVariable Integer spaceId,
+            @PathVariable Integer folderId,
+            @AuthenticationPrincipal CustomUserDetails userDetails
+    ) {
+        Integer target = (folderId == 0)
+                ? spaceArchiveFolderService.getDefaultFolderId(spaceId, userDetails.getMember())
+                : folderId;
+
+        FolderFilesDto rs = spaceArchiveFolderService.getFilesInFolder(spaceId, userDetails.getMember(), target);
+
+        return ResponseEntity.ok().body(
+                new RsData<>("200", "폴더 안의 파일 목록을 불러왔습니다.", rs)
+        );
+    }
+}
+
diff --git a/src/main/java/org/tuna/zoopzoop/backend/domain/space/archive/service/SpaceArchiveFolderService.java b/src/main/java/org/tuna/zoopzoop/backend/domain/space/archive/service/SpaceArchiveFolderService.java
new file mode 100644
index 00000000..bcc51ee9
--- /dev/null
+++ b/src/main/java/org/tuna/zoopzoop/backend/domain/space/archive/service/SpaceArchiveFolderService.java
@@ -0,0 +1,124 @@
+package org.tuna.zoopzoop.backend.domain.space.archive.service;
+
+import jakarta.persistence.NoResultException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.tuna.zoopzoop.backend.domain.archive.archive.entity.Archive;
+import org.tuna.zoopzoop.backend.domain.archive.archive.entity.SharingArchive;
+import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
+import org.tuna.zoopzoop.backend.domain.archive.folder.service.FolderService;
+import org.tuna.zoopzoop.backend.domain.datasource.dto.FolderFilesDto;
+import org.tuna.zoopzoop.backend.domain.member.entity.Member;
+import org.tuna.zoopzoop.backend.domain.space.membership.enums.Authority;
+import org.tuna.zoopzoop.backend.domain.space.membership.service.MembershipService;
+import org.tuna.zoopzoop.backend.domain.space.space.entity.Space;
+import org.tuna.zoopzoop.backend.domain.space.space.service.SpaceService;
+
+import java.util.List;
+import java.util.Optional;
+
+// package org.tuna.zoopzoop.backend.domain.space.archive.service;
+
+@Service
+@RequiredArgsConstructor
+public class SpaceArchiveFolderService {
+
+    private final SpaceService spaceService;
+    private final MembershipService membershipService;
+    private final FolderService folderService;
+
+    @Transactional
+    public FolderResponse createFolder(Integer spaceId, Member requester, String folderName) {
+        Space space = spaceService.findById(spaceId);
+
+        if (!membershipService.isMemberJoinedSpace(requester, space))
+            throw new SecurityException("스페이스의 구성원이 아닙니다.");
+
+        var m = membershipService.findByMemberAndSpace(requester, space);
+        var auth = m.getAuthority();
+        if (auth == Authority.PENDING || auth == Authority.READ_ONLY)
+            throw new SecurityException("폴더 생성 권한이 없습니다.");
+
+        Archive archive = Optional.ofNullable(space.getSharingArchive())
+                .map(SharingArchive::getArchive)
+                .orElseThrow(() -> new NoResultException("스페이스의 공유 아카이브가 없습니다."));
+
+        return folderService.createFolder(archive, folderName);
+    }
+
+    @Transactional
+    public String deleteFolder(Integer spaceId, Member requester, Integer folderId) {
+        Space space = spaceService.findById(spaceId);
+        if (!membershipService.isMemberJoinedSpace(requester, space))
+            throw new SecurityException("스페이스의 구성원이 아닙니다.");
+
+        var m = membershipService.findByMemberAndSpace(requester, space);
+        var auth = m.getAuthority();
+        if (auth == Authority.PENDING || auth == Authority.READ_ONLY)
+            throw new SecurityException("폴더 삭제 권한이 없습니다.");
+
+        Archive archive = Optional.ofNullable(space.getSharingArchive())
+                .map(SharingArchive::getArchive)
+                .orElseThrow(() -> new NoResultException("스페이스의 공유 아카이브가 없습니다."));
+
+        return folderService.deleteFolder(archive, folderId);
+    }
+
+    @Transactional
+    public String updateFolderName(Integer spaceId, Member requester, Integer folderId, String newName) {
+        Space space = spaceService.findById(spaceId);
+        if (!membershipService.isMemberJoinedSpace(requester, space))
+            throw new SecurityException("스페이스의 구성원이 아닙니다.");
+
+        var m = membershipService.findByMemberAndSpace(requester, space);
+        var auth = m.getAuthority();
+        if (auth == Authority.PENDING || auth == Authority.READ_ONLY)
+            throw new SecurityException("폴더 수정 권한이 없습니다.");
+
+        Archive archive = Optional.ofNullable(space.getSharingArchive())
+                .map(SharingArchive::getArchive)
+                .orElseThrow(() -> new NoResultException("스페이스의 공유 아카이브가 없습니다."));
+
+        return folderService.updateFolderName(archive, folderId, newName);
+    }
+
+    @Transactional(readOnly = true)
+    public List<FolderResponse> getFolders(Integer spaceId, Member requester) {
+        Space space = spaceService.findById(spaceId);
+        if (!membershipService.isMemberInSpace(requester, space)) // 읽기: PENDING도 허용할지 정책대로
+            throw new SecurityException("스페이스의 구성원이 아닙니다.");
+
+        Archive archive = Optional.ofNullable(space.getSharingArchive())
+                .map(SharingArchive::getArchive)
+                .orElseThrow(() -> new NoResultException("스페이스의 공유 아카이브가 없습니다."));
+
+        return folderService.getFolders(archive);
+    }
+
+    @Transactional(readOnly = true)
+    public FolderFilesDto getFilesInFolder(Integer spaceId, Member requester, Integer folderId) {
+        Space space = spaceService.findById(spaceId);
+        if (!membershipService.isMemberInSpace(requester, space))
+            throw new SecurityException("스페이스의 구성원이 아닙니다.");
+
+        Archive archive = Optional.ofNullable(space.getSharingArchive())
+                .map(SharingArchive::getArchive)
+                .orElseThrow(() -> new NoResultException("스페이스의 공유 아카이브가 없습니다."));
+
+        return folderService.getFilesInFolder(archive, folderId);
+    }
+
+    @Transactional(readOnly = true)
+    public Integer getDefaultFolderId(Integer spaceId, Member requester) {
+        Space space = spaceService.findById(spaceId);
+        if (!membershipService.isMemberInSpace(requester, space))
+            throw new SecurityException("스페이스의 구성원이 아닙니다.");
+
+        Archive archive = Optional.ofNullable(space.getSharingArchive())
+                .map(SharingArchive::getArchive)
+                .orElseThrow(() -> new NoResultException("스페이스의 공유 아카이브가 없습니다."));
+
+        return folderService.getDefaultFolderId(archive);
+    }
+}
diff --git a/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/controller/FolderControllerTest.java b/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/controller/FolderControllerTest.java
index 604ce50e..59e9e9c8 100644
--- a/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/controller/FolderControllerTest.java
+++ b/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/controller/FolderControllerTest.java
@@ -13,8 +13,8 @@
 import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
 import org.tuna.zoopzoop.backend.domain.archive.folder.dto.reqBodyForCreateFolder;
 import org.tuna.zoopzoop.backend.domain.archive.folder.entity.Folder;
-import org.tuna.zoopzoop.backend.domain.archive.folder.service.FolderService;
 import org.tuna.zoopzoop.backend.domain.archive.folder.repository.FolderRepository;
+import org.tuna.zoopzoop.backend.domain.archive.folder.service.PersonalArchiveFolderService;
 import org.tuna.zoopzoop.backend.domain.datasource.entity.Category;
 import org.tuna.zoopzoop.backend.domain.datasource.entity.DataSource;
 import org.tuna.zoopzoop.backend.domain.datasource.entity.Tag;
@@ -32,7 +32,11 @@
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
 
-
+/**
+ * 개인 아카이브 폴더 컨트롤러 통합 테스트 (MockMvc)
+ * - 전역 예외 핸들러를 통해 RsData(JSON)로 응답함
+ * - 응답의 "status" 값은 문자열("200","400","404",...)로 검증
+ */
 @ActiveProfiles("test")
 @SpringBootTest
 @AutoConfigureMockMvc
@@ -46,12 +50,12 @@ class FolderControllerTest {
     @Autowired private MemberService memberService;
     @Autowired private MemberRepository memberRepository;
 
-    @Autowired private FolderService folderService;
+    @Autowired private PersonalArchiveFolderService personalArchiveFolderService;
     @Autowired private FolderRepository folderRepository;
 
     @Autowired private DataSourceRepository dataSourceRepository;
 
-    private final String TEST_PROVIDER_KEY = "sc1111"; // WithUserDetails 에서 사용되는 provider key ("KAKAO:sc1111")
+    private final String TEST_PROVIDER_KEY = "sc1111";
     private Integer testMemberId;
     private Integer docsFolderId;
 
@@ -65,13 +69,12 @@ void beforeAll() {
                 .map(BaseEntity::getId)
                 .orElseThrow();
 
-        // GIVEN: 테스트용 폴더 및 샘플 자료 준비 (docs 폴더 + 2개 자료)
-        FolderResponse fr = folderService.createFolderForPersonal(testMemberId, "docs");
+        // given
+        FolderResponse fr = personalArchiveFolderService.createFolder(testMemberId, "docs");
         docsFolderId = fr.folderId();
 
         Folder docsFolder = folderRepository.findById(docsFolderId).orElseThrow();
 
-        // 자료 2건 생성
         DataSource d1 = new DataSource();
         d1.setFolder(docsFolder);
         d1.setTitle("spec.pdf");
@@ -81,7 +84,7 @@ void beforeAll() {
         d1.setDataCreatedDate(LocalDate.now());
         d1.setActive(true);
         d1.setTags(List.of(new Tag("tag1"), new Tag("tag2")));
-        d1.setCategory(Category.IT); // enum 타입 반영
+        d1.setCategory(Category.IT);
         dataSourceRepository.save(d1);
 
         DataSource d2 = new DataSource();
@@ -107,15 +110,13 @@ void afterAll() {
         } catch (Exception ignored) {}
     }
 
-    // CreateFile
+    // ---------- Create ----------
     @Test
     @DisplayName("개인 아카이브 폴더 생성 - 성공 시 200과 응답 DTO 반환")
     @WithUserDetails("KAKAO:sc1111")
     void createFolder_ok() throws Exception {
-        // Given
         var req = new reqBodyForCreateFolder("보고서");
 
-        // When & Then
         mockMvc.perform(post("/api/v1/archive/folder")
                         .contentType(MediaType.APPLICATION_JSON)
                         .content(objectMapper.writeValueAsString(req)))
@@ -130,40 +131,37 @@ void createFolder_ok() throws Exception {
     @DisplayName("개인 아카이브 폴더 생성 - 폴더 이름 누락 시 400")
     @WithUserDetails("KAKAO:sc1111")
     void createFolder_missingName() throws Exception {
-        // Given
         var req = new reqBodyForCreateFolder(null);
 
-        // When & Then
         mockMvc.perform(post("/api/v1/archive/folder")
                         .contentType(MediaType.APPLICATION_JSON)
                         .content(objectMapper.writeValueAsString(req)))
-                .andExpect(status().isBadRequest());
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.status").value("400"));
     }
 
-
-    // DeleteFile
+    // ---------- Delete ----------
     @Test
     @DisplayName("개인 아카이브 폴더 삭제 - 성공 시 200과 삭제 메시지 반환")
     @WithUserDetails("KAKAO:sc1111")
     void deleteFolder_ok() throws Exception {
-        // Given: 새 폴더 생성 후 삭제 준비
-        FolderResponse fr = folderService.createFolderForPersonal(testMemberId, "todelete");
+        FolderResponse fr = personalArchiveFolderService.createFolder(testMemberId, "todelete");
         Integer idToDelete = fr.folderId();
 
-        // When & Then
         mockMvc.perform(delete("/api/v1/archive/folder/{folderId}", idToDelete))
                 .andExpect(status().isOk())
-                .andExpect(jsonPath("$.status").value(200))
-                .andExpect(jsonPath("$.msg").value("todelete 폴더가 삭제됐습니다."));
+                .andExpect(jsonPath("$.status").value("200"))
+                .andExpect(jsonPath("$.msg").value("todelete 폴더가 삭제됐습니다."))
+                .andExpect(jsonPath("$.data").doesNotExist());
     }
 
     @Test
-    @DisplayName("개인 아카이브 폴더 삭제 실패- 기본 폴더면 400")
+    @DisplayName("개인 아카이브 폴더 삭제 실패 - 기본 폴더면 400")
     @WithUserDetails("KAKAO:sc1111")
     void deleteDefaultFolder_badRequest() throws Exception {
         mockMvc.perform(delete("/api/v1/archive/folder/{folderId}", 0))
                 .andExpect(status().isBadRequest())
-                .andExpect(jsonPath("$.status").value(409))
+                .andExpect(jsonPath("$.status").value("400"))
                 .andExpect(jsonPath("$.msg").value("default 폴더는 삭제할 수 없습니다."))
                 .andExpect(jsonPath("$.data").value(nullValue()));
     }
@@ -172,32 +170,28 @@ void deleteDefaultFolder_badRequest() throws Exception {
     @DisplayName("개인 아카이브 폴더 삭제 - 존재하지 않으면 404")
     @WithUserDetails("KAKAO:sc1111")
     void deleteFolder_notFound() throws Exception {
-        // When & Then
         mockMvc.perform(delete("/api/v1/archive/folder/{folderId}", 999999))
                 .andExpect(status().isNotFound())
                 .andExpect(jsonPath("$.status").value("404"))
                 .andExpect(jsonPath("$.msg").value("존재하지 않는 폴더입니다."));
     }
 
-
-    // UpdateFile
+    // ---------- Update ----------
     @Test
     @DisplayName("개인 아카이브 폴더 이름 변경 - 성공 시 200과 변경된 이름 반환")
     @WithUserDetails("KAKAO:sc1111")
     void updateFolder_ok() throws Exception {
-        // Given: rename 대상 폴더 생성
-        FolderResponse fr = folderService.createFolderForPersonal(testMemberId, "toRename");
+        FolderResponse fr = personalArchiveFolderService.createFolder(testMemberId, "toRename");
         Integer id = fr.folderId();
 
         var body = new java.util.HashMap<String,String>();
         body.put("folderName","회의록");
 
-        // When & Then
         mockMvc.perform(patch("/api/v1/archive/folder/{folderId}", id)
                         .contentType(MediaType.APPLICATION_JSON)
                         .content(objectMapper.writeValueAsString(body)))
                 .andExpect(status().isOk())
-                .andExpect(jsonPath("$.status").value(200))
+                .andExpect(jsonPath("$.status").value("200"))
                 .andExpect(jsonPath("$.msg").value("폴더 이름이 회의록 으로 변경됐습니다."))
                 .andExpect(jsonPath("$.data.folderName").value("회의록"));
     }
@@ -213,7 +207,7 @@ void updateDefaultFolder_badRequest() throws Exception {
                         .contentType(MediaType.APPLICATION_JSON)
                         .content(objectMapper.writeValueAsString(body)))
                 .andExpect(status().isBadRequest())
-                .andExpect(jsonPath("$.status").value(400))
+                .andExpect(jsonPath("$.status").value("400"))
                 .andExpect(jsonPath("$.msg").value("default 폴더는 이름을 변경할 수 없습니다."))
                 .andExpect(jsonPath("$.data").value(nullValue()));
     }
@@ -222,11 +216,9 @@ void updateDefaultFolder_badRequest() throws Exception {
     @DisplayName("개인 아카이브 폴더 이름 변경 - 존재하지 않는 폴더면 404")
     @WithUserDetails("KAKAO:sc1111")
     void updateFolder_notFound() throws Exception {
-        // Given
         var body = new java.util.HashMap<String,String>();
         body.put("folderName","회의록");
 
-        // When & Then
         mockMvc.perform(patch("/api/v1/archive/folder/{folderId}", 999999)
                         .contentType(MediaType.APPLICATION_JSON)
                         .content(objectMapper.writeValueAsString(body)))
@@ -235,33 +227,27 @@ void updateFolder_notFound() throws Exception {
                 .andExpect(jsonPath("$.msg").value("존재하지 않는 폴더입니다."));
     }
 
-    // ReadFolder
-    // Read: 내 폴더 목록
+    // ---------- Read ----------
     @Test
     @DisplayName("개인 아카이브 폴더 목록 조회 - 성공")
     @WithUserDetails("KAKAO:sc1111")
     void getFolders_success() throws Exception {
-        // When & Then
         mockMvc.perform(get("/api/v1/archive/folder")
                         .accept(MediaType.APPLICATION_JSON))
                 .andExpect(status().isOk())
-                .andExpect(jsonPath("$.status").value(200))
+                .andExpect(jsonPath("$.status").value("200"))
                 .andExpect(jsonPath("$.msg").value("개인 아카이브의 폴더 목록을 불러왔습니다."))
-                .andExpect(jsonPath("$.data.folders").isArray());
+                .andExpect(jsonPath("$.data").isArray());
     }
 
-    // Read: 폴더 내 파일 목록
     @Test
-    @DisplayName("폴더 내 파일 목록 조회 - 성공")
+    @DisplayName("개인 아카이브 폴더 내 파일 목록 조회 - 성공")
     @WithUserDetails("KAKAO:sc1111")
     void getFilesInFolder_success() throws Exception {
-        // Given : @BeforeAll: docsFolderId 및 샘플 파일 준비됨
-
-        // When & Then
         mockMvc.perform(get("/api/v1/archive/folder/{folderId}/files", docsFolderId)
                         .accept(MediaType.APPLICATION_JSON))
                 .andExpect(status().isOk())
-                .andExpect(jsonPath("$.status").value(200))
+                .andExpect(jsonPath("$.status").value("200"))
                 .andExpect(jsonPath("$.msg").value("해당 폴더의 파일 목록을 불러왔습니다."))
                 .andExpect(jsonPath("$.data.files").isArray())
                 .andExpect(jsonPath("$.data.files.length()").value(greaterThanOrEqualTo(2)))
@@ -273,25 +259,24 @@ void getFilesInFolder_success() throws Exception {
     }
 
     @Test
-    @DisplayName("폴더 파일 목록 조회 - default 폴더 성공")
+    @DisplayName("개인 아카이브 기본 폴더 내 파일 목록 조회 - 성공")
     @WithUserDetails("KAKAO:sc1111")
     void getFilesInDefaultFolder_success() throws Exception {
         mockMvc.perform(get("/api/v1/archive/folder/{folderId}/files", 0)
                         .accept(MediaType.APPLICATION_JSON))
                 .andExpect(status().isOk())
-                .andExpect(jsonPath("$.status").value(200))
-                .andExpect(jsonPath("$.msg").value("기본 폴더의 파일 목록을 불러왔습니다."))
-                .andExpect(jsonPath("$.data.folder.folderId").isNumber())
-                .andExpect(jsonPath("$.data.folder.folderName").isString())
+                .andExpect(jsonPath("$.status").value("200"))
+
+                .andExpect(jsonPath("$.msg").value("해당 폴더의 파일 목록을 불러왔습니다."))
+                .andExpect(jsonPath("$.data.folderId").isNumber())
+                .andExpect(jsonPath("$.data.folderName").isString())
                 .andExpect(jsonPath("$.data.files").isArray());
     }
 
-
     @Test
-    @DisplayName("폴더 내 파일 목록 조회 - 폴더가 없으면 404")
+    @DisplayName("개인 아카이브 폴더 내 파일 목록 조회 - 폴더가 없으면 404")
     @WithUserDetails("KAKAO:sc1111")
     void getFilesInFolder_notFound() throws Exception {
-        // When & Then
         mockMvc.perform(get("/api/v1/archive/folder/{folderId}/files", 999999)
                         .accept(MediaType.APPLICATION_JSON))
                 .andExpect(status().isNotFound())
diff --git a/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/FolderServiceTest.java b/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/FolderServiceTest.java
index fb0f4457..4504d04f 100644
--- a/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/FolderServiceTest.java
+++ b/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/FolderServiceTest.java
@@ -8,24 +8,18 @@
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.test.context.ActiveProfiles;
 import org.springframework.test.util.ReflectionTestUtils;
-import org.springframework.transaction.annotation.Transactional;
 import org.tuna.zoopzoop.backend.domain.archive.archive.entity.Archive;
-import org.tuna.zoopzoop.backend.domain.archive.archive.entity.PersonalArchive;
-import org.tuna.zoopzoop.backend.domain.archive.archive.repository.PersonalArchiveRepository;
 import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
 import org.tuna.zoopzoop.backend.domain.archive.folder.entity.Folder;
 import org.tuna.zoopzoop.backend.domain.archive.folder.repository.FolderRepository;
-import org.tuna.zoopzoop.backend.domain.datasource.entity.Category;
-import org.tuna.zoopzoop.backend.domain.datasource.dto.FolderFilesDto;
 import org.tuna.zoopzoop.backend.domain.datasource.dto.FileSummary;
+import org.tuna.zoopzoop.backend.domain.datasource.dto.FolderFilesDto;
 import org.tuna.zoopzoop.backend.domain.datasource.entity.DataSource;
 import org.tuna.zoopzoop.backend.domain.datasource.entity.Tag;
 import org.tuna.zoopzoop.backend.domain.datasource.repository.DataSourceRepository;
-import org.tuna.zoopzoop.backend.domain.member.entity.Member;
-import org.tuna.zoopzoop.backend.domain.member.repository.MemberRepository;
 
+import java.time.LocalDate;
 import java.util.List;
 import java.util.Optional;
 
@@ -34,310 +28,198 @@
 import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
-/**
- * FolderService 단위 테스트
- * - memberRepository 스텁은 필요한 테스트에만 선언
- */
 @ExtendWith(MockitoExtension.class)
-@Transactional
-@ActiveProfiles("test")
 class FolderServiceTest {
 
-    @Mock private MemberRepository memberRepository;
-    @Mock private PersonalArchiveRepository personalArchiveRepository;
     @Mock private FolderRepository folderRepository;
     @Mock private DataSourceRepository dataSourceRepository;
 
     @InjectMocks private FolderService folderService;
 
-    private Member member;
     private Archive archive;
-    private PersonalArchive personalArchive;
 
     @BeforeEach
     void setUp() {
-        // 공통 테스트 데이터 준비 (스텁은 각 테스트에서 선언)
-        this.member = new Member();
-        ReflectionTestUtils.setField(member, "id", 1);
-
         this.archive = new Archive();
         ReflectionTestUtils.setField(archive, "id", 10);
-
-        this.personalArchive = new PersonalArchive();
-        ReflectionTestUtils.setField(personalArchive, "id", 100);
-        personalArchive.setMember(member);
-        personalArchive.setArchive(archive);
     }
 
     // ---------- Create ----------
     @Test
-    @DisplayName("폴더 생성 성공(중복 없음)")
-    void createFolder_success() {
-        // GIVEN
-        when(memberRepository.findById(1)).thenReturn(Optional.of(member)); // <- 반드시 필요
-        when(personalArchiveRepository.findByMemberId(1)).thenReturn(Optional.of(personalArchive));
+    @DisplayName("폴더 이름 중복 없음 → 그대로 생성")
+    void generateUniqueName_noConflict() {
         when(folderRepository.findNamesForConflictCheck(eq(archive.getId()), anyString(), anyString()))
                 .thenReturn(List.of());
 
-        Folder saved = new Folder();
-        saved.setName("보고서");
-        saved.setArchive(archive);
-        ReflectionTestUtils.setField(saved, "id", 999);
+        Folder folder = new Folder();
+        folder.setArchive(archive);
+        folder.setName("보고서");
+        ReflectionTestUtils.setField(folder, "id", 1);
 
-        when(folderRepository.save(any(Folder.class))).thenReturn(saved);
+        when(folderRepository.save(any(Folder.class))).thenReturn(folder);
 
-        // WHEN
-        FolderResponse result = folderService.createFolderForPersonal(1, "보고서");
+        FolderResponse rs = folderService.createFolder(archive, "보고서");
 
-        // THEN
-        assertThat(result.folderId()).isEqualTo(999);
-        assertThat(result.folderName()).isEqualTo("보고서");
+        assertThat(rs.folderName()).isEqualTo("보고서");
     }
 
     @Test
-    @DisplayName("폴더 이름 중복 시 '(1)' 붙여 생성")
-    void createFolder_withConflict() {
-        // given
-        when(memberRepository.findById(1)).thenReturn(Optional.of(member)); // <- 반드시 필요
-        when(personalArchiveRepository.findByMemberId(1)).thenReturn(Optional.of(personalArchive));
+    @DisplayName("폴더 이름 중복 시 (1) 붙여 생성")
+    void generateUniqueName_withConflict() {
         when(folderRepository.findNamesForConflictCheck(eq(archive.getId()), eq("보고서"), anyString()))
                 .thenReturn(List.of("보고서"));
 
-        Folder saved = new Folder();
-        saved.setName("보고서 (1)");
-        saved.setArchive(archive);
-        ReflectionTestUtils.setField(saved, "id", 1000);
-
-        when(folderRepository.save(any(Folder.class))).thenReturn(saved);
-
-        // when
-        FolderResponse result = folderService.createFolderForPersonal(1, "보고서");
+        Folder folder = new Folder();
+        folder.setArchive(archive);
+        folder.setName("보고서 (1)");
+        ReflectionTestUtils.setField(folder, "id", 2);
 
-        // then
-        assertThat(result.folderName()).isEqualTo("보고서 (1)");
-        assertThat(result.folderId()).isEqualTo(1000);
-    }
+        when(folderRepository.save(any(Folder.class))).thenReturn(folder);
 
-    @Test
-    @DisplayName("멤버가 없으면 예외 발생")
-    void createFolder_memberNotFound() {
-        // given
-        when(memberRepository.findById(2)).thenReturn(Optional.empty());
+        FolderResponse rs = folderService.createFolder(archive, "보고서");
 
-        // when & then
-        assertThrows(NoResultException.class,
-                () -> folderService.createFolderForPersonal(2, "보고서"));
+        assertThat(rs.folderName()).isEqualTo("보고서 (1)");
     }
 
     // ---------- Delete ----------
     @Test
-    @DisplayName("폴더 삭제 성공 - 자료는 default 폴더로 이관 + soft delete 후 폴더 영구삭제")
-    void deleteFolder_success() {
-        // given
-        // 삭제 대상 폴더
-        Folder folder = new Folder();
-        folder.setName("보고서");
-        folder.setArchive(archive);
-        ReflectionTestUtils.setField(folder, "id", 500);
-
-        // 기본 폴더 스텁 (회원의 default 폴더)
-        Folder defaultFolder = new Folder("default"); // 생성자에서 isDefault=true 설정이라면 그대로 사용
+    @DisplayName("폴더 삭제 시 자료는 default 폴더로 이관 + soft delete")
+    void deleteFolder_softDeleteAndMove() {
+        Folder target = new Folder();
+        target.setArchive(archive);
+        target.setName("docs");
+        ReflectionTestUtils.setField(target, "id", 100);
+
+        Folder defaultFolder = new Folder();
         defaultFolder.setArchive(archive);
-        ReflectionTestUtils.setField(defaultFolder, "id", 42);
+        defaultFolder.setName("default");
+        defaultFolder.setDefault(true);
+        ReflectionTestUtils.setField(defaultFolder, "id", 200);
 
-        // 폴더 내 자료들 (이관 + soft delete가 적용될 대상)
-        DataSource d1 = new DataSource(); ReflectionTestUtils.setField(d1, "id", 1); d1.setFolder(folder); d1.setActive(true);
-        DataSource d2 = new DataSource(); ReflectionTestUtils.setField(d2, "id", 2); d2.setFolder(folder); d2.setActive(true);
+        DataSource d1 = new DataSource(); ReflectionTestUtils.setField(d1, "id", 1); d1.setFolder(target); d1.setActive(true);
+        DataSource d2 = new DataSource(); ReflectionTestUtils.setField(d2, "id", 2); d2.setFolder(target); d2.setActive(true);
 
+        when(folderRepository.findByIdAndArchiveId(100, 10))
+                .thenReturn(Optional.of(target));
+        when(folderRepository.findByArchiveIdAndIsDefaultTrue(10))
+                .thenReturn(Optional.of(defaultFolder));
+        when(dataSourceRepository.findAllByFolderId(100))
+                .thenReturn(List.of(d1, d2));
 
-        when(folderRepository.findByIdAndMemberId(500, 1)).thenReturn(Optional.of(folder));
-        when(folderRepository.findDefaultByMemberId(1)).thenReturn(Optional.of(defaultFolder));
+        String deleted = folderService.deleteFolder(archive, 100);
 
-        when(dataSourceRepository.findAllByFolderId(500)).thenReturn(List.of(d1, d2));
-
-
-        // when
-        String deletedName = folderService.deleteFolder(1, 500);
-
-        // then
-        assertThat(deletedName).isEqualTo("보고서");
-
-        // 자료들이 default 폴더로 이관 + soft delete 되었는지 확인
-        assertThat(d1.getFolder().getId()).isEqualTo(defaultFolder.getId());
-        assertThat(d2.getFolder().getId()).isEqualTo(defaultFolder.getId());
+        assertThat(deleted).isEqualTo("docs");
         assertThat(d1.isActive()).isFalse();
-        assertThat(d2.isActive()).isFalse();
         assertThat(d1.getDeletedAt()).isNotNull();
-        assertThat(d2.getDeletedAt()).isNotNull();
-
-        // 마지막에 폴더 삭제 호출
-        verify(folderRepository, times(1)).delete(folder);
+        assertThat(d1.getFolder()).isEqualTo(defaultFolder);
+        verify(folderRepository, times(1)).delete(target);
     }
 
-
-
     @Test
     @DisplayName("폴더 삭제 실패 - 존재하지 않는 폴더")
     void deleteFolder_notFound() {
-        // given
-        when(folderRepository.findByIdAndMemberId(999, 1)).thenReturn(Optional.empty());
-
-        // when & then
-        assertThrows(NoResultException.class, () -> folderService.deleteFolder(1, 999));
-        verify(folderRepository, never()).delete(any(Folder.class));
-    }
-
-    @Test
-    @DisplayName("default 폴더는 삭제할 수 없다")
-    void deleteFolder_default_forbidden() {
-        // given
-        Folder defaultFolder = new Folder("default"); // isDefault=true
-        ReflectionTestUtils.setField(defaultFolder, "id", 42);
-
-        when(folderRepository.findByIdAndMemberId(42, 1)).thenReturn(Optional.of(defaultFolder));
+        when(folderRepository.findByIdAndArchiveId(999, archive.getId()))
+                .thenReturn(Optional.empty());
 
-        // when & then
-        assertThrows(IllegalArgumentException.class, () -> folderService.deleteFolder(1, 42));
-        verify(folderRepository, never()).delete(any());
+        assertThrows(NoResultException.class, () -> folderService.deleteFolder(archive, 999));
     }
 
     // ---------- Update ----------
     @Test
     @DisplayName("폴더 이름 변경 성공")
     void updateFolderName_success() {
-        // given
         Folder folder = new Folder();
-        folder.setName("기존이름");
         folder.setArchive(archive);
-        ReflectionTestUtils.setField(folder, "id", 700);
+        folder.setName("기존");
+        ReflectionTestUtils.setField(folder, "id", 300);
 
-        when(folderRepository.findByIdAndMemberId(700, 1)).thenReturn(Optional.of(folder));
-        when(folderRepository.findNamesForConflictCheck(archive.getId(), "새이름", folder.getName()))
+        when(folderRepository.findByIdAndArchiveId(300, archive.getId()))
+                .thenReturn(Optional.of(folder));
+        when(folderRepository.existsNameInArchiveExceptSelf(archive.getId(), "새이름", folder.getId()))
                 .thenReturn(List.of());
-        when(folderRepository.save(any(Folder.class))).thenAnswer(invocation -> invocation.getArgument(0));
+        when(folderRepository.save(any(Folder.class))).thenAnswer(inv -> inv.getArgument(0));
 
-        // when
-        String updated = folderService.updateFolderName(1, 700, "새이름");
+        String updated = folderService.updateFolderName(archive, 300, "새이름");
 
-        // then
         assertThat(updated).isEqualTo("새이름");
         assertThat(folder.getName()).isEqualTo("새이름");
-        verify(folderRepository, times(1)).save(folder);
-    }
-
-    @Test
-    @DisplayName("폴더 이름 변경 실패 - 존재하지 않음")
-    void updateFolderName_notFound() {
-        // given
-        when(folderRepository.findByIdAndMemberId(701, 1)).thenReturn(Optional.empty());
-
-        // when & then
-        assertThrows(NoResultException.class, () -> folderService.updateFolderName(1, 701, "아무거나"));
-        verify(folderRepository, never()).save(any(Folder.class));
     }
 
     @Test
     @DisplayName("폴더 이름 변경 실패 - 중복 이름 존재")
     void updateFolderName_conflict() {
-        // given
         Folder folder = new Folder();
-        folder.setName("기존이름");
         folder.setArchive(archive);
-        ReflectionTestUtils.setField(folder, "id", 700);
+        folder.setName("기존");
+        ReflectionTestUtils.setField(folder, "id", 301);
 
-        when(folderRepository.findByIdAndMemberId(700, 1)).thenReturn(Optional.of(folder));
-        when(folderRepository.findNamesForConflictCheck(archive.getId(), "보고서", "기존이름"))
+        when(folderRepository.findByIdAndArchiveId(301, archive.getId()))
+                .thenReturn(Optional.of(folder));
+        when(folderRepository.existsNameInArchiveExceptSelf(archive.getId(), "보고서", folder.getId()))
                 .thenReturn(List.of("보고서"));
 
-        // when & then
         assertThrows(IllegalArgumentException.class,
-                () -> folderService.updateFolderName(1, 700, "보고서"));
+                () -> folderService.updateFolderName(archive, 301, "보고서"));
+    }
 
-        verify(folderRepository, never()).save(any(Folder.class));
+    @Test
+    @DisplayName("폴더 이름 변경 실패 - 폴더 없음")
+    void updateFolderName_notFound() {
+        when(folderRepository.findByIdAndArchiveId(302, archive.getId()))
+                .thenReturn(Optional.empty());
+
+        assertThrows(NoResultException.class,
+                () -> folderService.updateFolderName(archive, 302, "새이름"));
     }
 
-    // Read: Personal Archive 내 폴더 목록
+    // ---------- Read ----------
     @Test
-    @DisplayName("개인 아카이브 폴더 목록 조회 - 성공")
-    void getFoldersForPersonal_success() {
-        // given
-        Folder f1 = new Folder(); f1.setName("default"); f1.setArchive(archive); ReflectionTestUtils.setField(f1, "id", 1);
-        Folder f2 = new Folder(); f2.setName("docs");    f2.setArchive(archive); ReflectionTestUtils.setField(f2, "id", 2);
+    @DisplayName("Archive 단위 폴더 목록 조회 성공")
+    void getFolders_success() {
+        Folder f1 = new Folder(); f1.setArchive(archive); f1.setName("default"); ReflectionTestUtils.setField(f1, "id", 1);
+        Folder f2 = new Folder(); f2.setArchive(archive); f2.setName("docs");    ReflectionTestUtils.setField(f2, "id", 2);
 
-        when(personalArchiveRepository.findByMemberId(1)).thenReturn(Optional.of(personalArchive));
         when(folderRepository.findByArchive(archive)).thenReturn(List.of(f1, f2));
 
-        // when
-        List<FolderResponse> rs = folderService.getFoldersForPersonal(1);
+        List<FolderResponse> rs = folderService.getFolders(archive);
 
-        // then
         assertThat(rs).hasSize(2);
-        assertThat(rs.get(0).folderId()).isEqualTo(1);
         assertThat(rs.get(0).folderName()).isEqualTo("default");
         assertThat(rs.get(1).folderName()).isEqualTo("docs");
-        verify(folderRepository, times(1)).findByArchive(archive);
     }
 
-    // Read: 폴더 내 파일 목록
     @Test
-    @DisplayName("폴더 내 파일 목록 조회")
-    void getFilesInFolderForPersonal_success() {
-        // given
-        Integer folderId = 2;
-
+    @DisplayName("Archive 단위 폴더 내 파일 목록 조회 성공")
+    void getFilesInFolder_success() {
         Folder folder = new Folder();
-        folder.setName("docs");
         folder.setArchive(archive);
-        ReflectionTestUtils.setField(folder, "id", folderId);
-
-        when(folderRepository.findByIdAndMemberId(folderId, 1)).thenReturn(Optional.of(folder));
-
-        DataSource d1 = new DataSource();
-        ReflectionTestUtils.setField(d1, "id", 10);
-        d1.setTitle("spec.pdf");
-        d1.setFolder(folder);
-        d1.setSummary("요약 A");
-        d1.setSourceUrl("http://src/a");
-        d1.setImageUrl("http://img/a");
-        d1.setTags(List.of(new Tag("tag1"), new Tag("tag2")));
-        d1.setCategory(Category.IT);
-
-        DataSource d2 = new DataSource();
-        ReflectionTestUtils.setField(d2, "id", 11);
-        d2.setTitle("notes.txt");
-        d2.setFolder(folder);
-        d2.setSummary("요약 B");
-        d2.setSourceUrl("http://src/b");
-        d2.setImageUrl("http://img/b");
-        d2.setTags(List.of());
-        d2.setCategory(Category.SCIENCE);
-
-        when(dataSourceRepository.findAllByFolder(folder)).thenReturn(List.of(d1, d2));
-
-        // when
-        FolderFilesDto dto = folderService.getFilesInFolderForPersonal(1, folderId);
-
-        // then
-        assertThat(dto.files()).hasSize(2);
-        FileSummary f0 = dto.files().getFirst();
-        assertThat(f0.dataSourceId()).isEqualTo(10);
-        assertThat(f0.title()).isEqualTo("spec.pdf");
-        assertThat(f0.summary()).isEqualTo("요약 A");
-        assertThat(f0.sourceUrl()).isEqualTo("http://src/a");
-        assertThat(f0.imageUrl()).isEqualTo("http://img/a");
-        assertThat(f0.tags()).containsExactly("tag1", "tag2");
+        folder.setName("docs");
+        ReflectionTestUtils.setField(folder, "id", 400);
+
+        DataSource d1 = new DataSource(); ReflectionTestUtils.setField(d1, "id", 1);
+        d1.setTitle("spec.pdf"); d1.setSummary("요약"); d1.setFolder(folder);
+        d1.setSourceUrl("http://src/a"); d1.setImageUrl("http://img/a");
+        d1.setDataCreatedDate(LocalDate.now());
+        d1.setTags(List.of(new Tag("tag1")));
+
+        when(folderRepository.findByIdAndArchiveId(eq(400), eq(archive.getId())))
+                .thenReturn(Optional.of(folder));
+        when(dataSourceRepository.findAllByFolder(folder)).thenReturn(List.of(d1));
+
+        FolderFilesDto dto = folderService.getFilesInFolder(archive, 400);
+
+        assertThat(dto.files()).hasSize(1);
+        FileSummary f = dto.files().getFirst();
+        assertThat(f.title()).isEqualTo("spec.pdf");
     }
 
     @Test
-    @DisplayName("폴더 내 파일 목록 조회 - 폴더가 없으면 예외 발생")
-    void getFilesInFolderForPersonal_notFound() {
-        // given
-        Integer folderId = 999;
-        when(folderRepository.findByIdAndMemberId(folderId, 1)).thenReturn(Optional.empty());
+    @DisplayName("Archive 단위 폴더 내 파일 목록 조회 실패 - 폴더 없음")
+    void getFilesInFolder_notFound() {
+        when(folderRepository.findByIdAndArchiveId(eq(999), eq(archive.getId())))
+                .thenReturn(Optional.empty());
 
-        // when & then
         assertThrows(NoResultException.class,
-                () -> folderService.getFilesInFolderForPersonal(1, folderId));
-        verify(dataSourceRepository, never()).findAllByFolder(any());
+                () -> folderService.getFilesInFolder(archive, 999));
     }
 }
diff --git a/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/PersonalArchiveFolderServiceTest.java b/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/PersonalArchiveFolderServiceTest.java
new file mode 100644
index 00000000..61aa2a10
--- /dev/null
+++ b/src/test/java/org/tuna/zoopzoop/backend/domain/archive/folder/service/PersonalArchiveFolderServiceTest.java
@@ -0,0 +1,289 @@
+package org.tuna.zoopzoop.backend.domain.archive.folder.service;
+
+import jakarta.persistence.NoResultException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.tuna.zoopzoop.backend.domain.archive.archive.entity.Archive;
+import org.tuna.zoopzoop.backend.domain.archive.archive.entity.PersonalArchive;
+import org.tuna.zoopzoop.backend.domain.archive.archive.repository.PersonalArchiveRepository;
+import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
+import org.tuna.zoopzoop.backend.domain.archive.folder.entity.Folder;
+import org.tuna.zoopzoop.backend.domain.archive.folder.repository.FolderRepository;
+import org.tuna.zoopzoop.backend.domain.datasource.dto.FolderFilesDto;
+
+import java.util.List;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class PersonalArchiveFolderServiceTest {
+
+    @Mock private PersonalArchiveRepository personalArchiveRepository;
+    @Mock private FolderRepository folderRepository;
+    @Mock private FolderService folderService;
+
+    @InjectMocks private PersonalArchiveFolderService personalService;
+
+    private Archive mockArchive() {
+        Archive a = new Archive();
+        ReflectionTestUtils.setField(a, "id", 10);
+        return a;
+    }
+
+    private PersonalArchive mockPersonalArchive(Archive a) {
+        PersonalArchive pa = new PersonalArchive();
+        ReflectionTestUtils.setField(pa, "id", 100);
+        pa.setArchive(a);
+        return pa;
+    }
+
+    private Folder mockFolder(Archive a, Integer id, String name) {
+        Folder f = new Folder();
+        f.setArchive(a);
+        f.setName(name);
+        ReflectionTestUtils.setField(f, "id", id);
+        return f;
+    }
+
+    // ---------------------- Create ----------------------
+    @Test
+    @DisplayName("개인 아카이브 폴더 생성 성공")
+    void createFolder_success() {
+        // given
+        Integer memberId = 1;
+        Archive archive = mockArchive();
+        PersonalArchive pa = mockPersonalArchive(archive);
+
+        when(personalArchiveRepository.findByMemberId(memberId)).thenReturn(Optional.of(pa));
+        when(folderService.createFolder(eq(archive), eq("보고서")))
+                .thenReturn(new FolderResponse("보고서", 999));
+
+        // when
+        FolderResponse rs = personalService.createFolder(memberId, "보고서");
+
+        // then
+        assertThat(rs.folderName()).isEqualTo("보고서");
+        assertThat(rs.folderId()).isEqualTo(999);
+        verify(folderService).createFolder(eq(archive), eq("보고서"));
+    }
+
+    @Test
+    @DisplayName("개인 아카이브 폴더 생성 실패 - 개인 아카이브 없음")
+    void createFolder_archiveNotFound() {
+        // given
+        Integer memberId = 1;
+        when(personalArchiveRepository.findByMemberId(memberId)).thenReturn(Optional.empty());
+
+        // when & then
+        assertThrows(NoResultException.class, () -> personalService.createFolder(memberId, "보고서"));
+        verify(folderService, never()).createFolder(any(), anyString());
+    }
+
+    // ---------------------- Delete ----------------------
+    @Test
+    @DisplayName("개인 아카이브 폴더 삭제 성공")
+    void deleteFolder_success() {
+        // given
+        Integer memberId = 1;
+        Integer folderId = 200;
+        Archive archive = mockArchive();
+        Folder folder = mockFolder(archive, folderId, "todelete");
+
+        when(folderRepository.findByIdAndMemberId(folderId, memberId)).thenReturn(Optional.of(folder));
+        when(folderService.deleteFolder(archive, folderId)).thenReturn("todelete");
+
+        // when
+        String deleted = personalService.deleteFolder(memberId, folderId);
+
+        // then
+        assertThat(deleted).isEqualTo("todelete");
+        verify(folderService).deleteFolder(eq(archive), eq(folderId));
+    }
+
+    @Test
+    @DisplayName("개인 아카이브 폴더 삭제 실패 - 존재하지 않는 폴더")
+    void deleteFolder_notFound() {
+        // given
+        Integer memberId = 1;
+        Integer folderId = 999;
+        when(folderRepository.findByIdAndMemberId(folderId, memberId)).thenReturn(Optional.empty());
+
+        // when & then
+        assertThrows(NoResultException.class, () -> personalService.deleteFolder(memberId, folderId));
+        verify(folderService, never()).deleteFolder(any(), anyInt());
+    }
+
+    @Test
+    @DisplayName("개인 아카이브 폴더 삭제 실패 - default 금지(공통 서비스 예외 전파)")
+    void deleteFolder_defaultForbidden() {
+        // given
+        Integer memberId = 1;
+        Integer folderId = 123;
+        Archive archive = mockArchive();
+        Folder folder = mockFolder(archive, folderId, "default?");
+        when(folderRepository.findByIdAndMemberId(folderId, memberId)).thenReturn(Optional.of(folder));
+        when(folderService.deleteFolder(archive, folderId))
+                .thenThrow(new IllegalArgumentException("default 폴더는 삭제할 수 없습니다."));
+
+        // when & then
+        assertThrows(IllegalArgumentException.class, () -> personalService.deleteFolder(memberId, folderId));
+        verify(folderService).deleteFolder(eq(archive), eq(folderId));
+    }
+
+    // ---------------------- Update ----------------------
+    @Test
+    @DisplayName("개인 아카이브 폴더 이름 변경 성공")
+    void updateFolderName_success() {
+        // given
+        Integer memberId = 1;
+        Integer folderId = 300;
+        Archive archive = mockArchive();
+        Folder folder = mockFolder(archive, folderId, "old");
+        when(folderRepository.findByIdAndMemberId(folderId, memberId)).thenReturn(Optional.of(folder));
+        when(folderService.updateFolderName(archive, folderId, "new")).thenReturn("new");
+
+        // when
+        String updated = personalService.updateFolderName(memberId, folderId, "new");
+
+        // then
+        assertThat(updated).isEqualTo("new");
+        verify(folderService).updateFolderName(eq(archive), eq(folderId), eq("new"));
+    }
+
+    @Test
+    @DisplayName("개인 아카이브 폴더 이름 변경 실패 - 폴더 없음")
+    void updateFolderName_notFound() {
+        // given
+        Integer memberId = 1;
+        Integer folderId = 301;
+        when(folderRepository.findByIdAndMemberId(folderId, memberId)).thenReturn(Optional.empty());
+
+        // when & then
+        assertThrows(NoResultException.class,
+                () -> personalService.updateFolderName(memberId, folderId, "new"));
+        verify(folderService, never()).updateFolderName(any(), anyInt(), anyString());
+    }
+
+    @Test
+    @DisplayName("개인 아카이브 폴더 이름 변경 실패 - 중복 이름(공통 서비스 예외 전파)")
+    void updateFolderName_conflict() {
+        // given
+        Integer memberId = 1;
+        Integer folderId = 302;
+        Archive archive = mockArchive();
+        Folder folder = mockFolder(archive, folderId, "old");
+        when(folderRepository.findByIdAndMemberId(folderId, memberId)).thenReturn(Optional.of(folder));
+        when(folderService.updateFolderName(archive, folderId, "보고서"))
+                .thenThrow(new IllegalArgumentException("이미 존재하는 폴더명입니다."));
+
+        // when & then
+        assertThrows(IllegalArgumentException.class,
+                () -> personalService.updateFolderName(memberId, folderId, "보고서"));
+        verify(folderService).updateFolderName(eq(archive), eq(folderId), eq("보고서"));
+    }
+
+    // ---------------------- Read ----------------------
+    @Test
+    @DisplayName("개인 아카이브 폴더 목록 조회 성공")
+    void getFolders_success() {
+        // given
+        Integer memberId = 1;
+        Archive archive = mockArchive();
+        PersonalArchive pa = mockPersonalArchive(archive);
+        when(personalArchiveRepository.findByMemberId(memberId)).thenReturn(Optional.of(pa));
+        when(folderService.getFolders(archive)).thenReturn(List.of(
+                new FolderResponse("default", 1),
+                new FolderResponse("docs", 2)
+        ));
+
+        // when
+        List<FolderResponse> rs = personalService.getFolders(memberId);
+
+        // then
+        assertThat(rs).hasSize(2);
+        assertThat(rs.getFirst().folderName()).isEqualTo("default");
+        verify(folderService).getFolders(eq(archive));
+    }
+
+    @Test
+    @DisplayName("개인 아카이브 폴더 목록 조회 실패 - 개인 아카이브 없음")
+    void getFolders_archiveNotFound() {
+        // given
+        Integer memberId = 1;
+        when(personalArchiveRepository.findByMemberId(memberId)).thenReturn(Optional.empty());
+
+        // when & then
+        assertThrows(NoResultException.class, () -> personalService.getFolders(memberId));
+        verify(folderService, never()).getFolders(any());
+    }
+
+    @Test
+    @DisplayName("개인 아카이브 폴더 내 파일 목록 조회 성공")
+    void getFilesInFolder_success() {
+        // given
+        Integer memberId = 1;
+        Integer folderId = 400;
+        Archive archive = mockArchive();
+        Folder folder = mockFolder(archive, folderId, "docs");
+        FolderFilesDto dto = new FolderFilesDto(folderId, "docs", List.of());
+        when(folderRepository.findByIdAndMemberId(folderId, memberId)).thenReturn(Optional.of(folder));
+        when(folderService.getFilesInFolder(archive, folderId)).thenReturn(dto);
+
+        // when
+        FolderFilesDto rs = personalService.getFilesInFolder(memberId, folderId);
+
+        // then
+        assertThat(rs.folderId()).isEqualTo(folderId);
+        assertThat(rs.folderName()).isEqualTo("docs");
+        verify(folderService).getFilesInFolder(eq(archive), eq(folderId));
+    }
+
+    @Test
+    @DisplayName("개인 아카이브 폴더 내 파일 목록 조회 실패 - 폴더 없음")
+    void getFilesInFolder_notFound() {
+        // given
+        Integer memberId = 1;
+        Integer folderId = 401;
+        when(folderRepository.findByIdAndMemberId(folderId, memberId)).thenReturn(Optional.empty());
+
+        // when & then
+        assertThrows(NoResultException.class,
+                () -> personalService.getFilesInFolder(memberId, folderId));
+        verify(folderService, never()).getFilesInFolder(any(), anyInt());
+    }
+
+    @Test
+    @DisplayName("default 폴더 ID 조회 성공")
+    void getDefaultFolderId_success() {
+        // given
+        Integer memberId = 1;
+        Folder defaultFolder = mockFolder(mockArchive(), 42, "default");
+        when(folderRepository.findDefaultFolderByMemberId(memberId)).thenReturn(Optional.of(defaultFolder));
+
+        // when
+        Integer id = personalService.getDefaultFolderId(memberId);
+
+        // then
+        assertThat(id).isEqualTo(42);
+    }
+
+    @Test
+    @DisplayName("default 폴더 ID 조회 실패 - 없음")
+    void getDefaultFolderId_notFound() {
+        // given
+        Integer memberId = 1;
+        when(folderRepository.findDefaultFolderByMemberId(memberId)).thenReturn(Optional.empty());
+
+        // when & then
+        assertThrows(NoResultException.class, () -> personalService.getDefaultFolderId(memberId));
+    }
+}
diff --git a/src/test/java/org/tuna/zoopzoop/backend/domain/datasource/controller/DatasourceControllerTest.java b/src/test/java/org/tuna/zoopzoop/backend/domain/datasource/controller/DatasourceControllerTest.java
index 9097875a..37a61089 100644
--- a/src/test/java/org/tuna/zoopzoop/backend/domain/datasource/controller/DatasourceControllerTest.java
+++ b/src/test/java/org/tuna/zoopzoop/backend/domain/datasource/controller/DatasourceControllerTest.java
@@ -19,7 +19,7 @@
 import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
 import org.tuna.zoopzoop.backend.domain.archive.folder.entity.Folder;
 import org.tuna.zoopzoop.backend.domain.archive.folder.repository.FolderRepository;
-import org.tuna.zoopzoop.backend.domain.archive.folder.service.FolderService;
+import org.tuna.zoopzoop.backend.domain.archive.folder.service.PersonalArchiveFolderService;
 import org.tuna.zoopzoop.backend.domain.datasource.dataprocessor.service.DataProcessorService;
 import org.tuna.zoopzoop.backend.domain.datasource.dto.DataSourceDto;
 import org.tuna.zoopzoop.backend.domain.datasource.dto.reqBodyForCreateDataSource;
@@ -55,7 +55,7 @@ class DatasourceControllerTest {
 
     @Autowired private MemberService memberService;
     @Autowired private MemberRepository memberRepository;
-    @Autowired private FolderService folderService;
+    @Autowired private PersonalArchiveFolderService folderService;
     @Autowired private FolderRepository folderRepository;
     @Autowired private DataSourceRepository dataSourceRepository;
 
@@ -116,7 +116,7 @@ void beforeAll() {
         testMemberId = member.getId();
 
         // docs 폴더 생성
-        FolderResponse fr = folderService.createFolderForPersonal(testMemberId, "docs");
+        FolderResponse fr = folderService.createFolder(testMemberId, "docs");
         docsFolderId = fr.folderId();
 
         Folder docsFolder = folderRepository.findById(docsFolderId).orElseThrow();
@@ -367,7 +367,7 @@ void restore_notFoundIds() throws Exception {
     @DisplayName("단건 이동 성공 -> 200")
     @WithUserDetails(value = "KAKAO:testUser_sc1111", setupBefore = TestExecutionEvent.TEST_METHOD)
     void moveOne_ok() throws Exception {
-        FolderResponse newFolder = folderService.createFolderForPersonal(testMemberId, "moveTarget");
+        FolderResponse newFolder = folderService.createFolder(testMemberId, "moveTarget");
         Integer toId = newFolder.folderId();
 
         var body = new reqBodyForMoveDataSource(toId);
@@ -426,7 +426,7 @@ void moveOne_notFound_folder() throws Exception {
     @DisplayName("자료 다건 이동 성공: 지정 폴더 -> 200")
     @WithUserDetails(value = "KAKAO:testUser_sc1111", setupBefore = TestExecutionEvent.TEST_METHOD)
     void moveMany_specific_ok() throws Exception {
-        FolderResponse newFolder = folderService.createFolderForPersonal(testMemberId, "moveManyTarget");
+        FolderResponse newFolder = folderService.createFolder(testMemberId, "moveManyTarget");
         Integer toId = newFolder.folderId();
 
         String body = String.format("{\"folderId\":%d,\"dataSourceId\":[%d,%d]}", toId, dataSourceId1, dataSourceId2);
diff --git a/src/test/java/org/tuna/zoopzoop/backend/domain/news/service/NewsServiceTest.java b/src/test/java/org/tuna/zoopzoop/backend/domain/news/service/NewsServiceTest.java
index a17fc15c..852fafbf 100644
--- a/src/test/java/org/tuna/zoopzoop/backend/domain/news/service/NewsServiceTest.java
+++ b/src/test/java/org/tuna/zoopzoop/backend/domain/news/service/NewsServiceTest.java
@@ -11,7 +11,7 @@
 import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
 import org.tuna.zoopzoop.backend.domain.archive.folder.entity.Folder;
 import org.tuna.zoopzoop.backend.domain.archive.folder.repository.FolderRepository;
-import org.tuna.zoopzoop.backend.domain.archive.folder.service.FolderService;
+import org.tuna.zoopzoop.backend.domain.archive.folder.service.PersonalArchiveFolderService;
 import org.tuna.zoopzoop.backend.domain.datasource.entity.Category;
 import org.tuna.zoopzoop.backend.domain.datasource.entity.DataSource;
 import org.tuna.zoopzoop.backend.domain.datasource.entity.Tag;
@@ -41,7 +41,7 @@ public class NewsServiceTest {
     private MemberRepository memberRepository;
 
     @Autowired
-    private FolderService folderService;
+    private PersonalArchiveFolderService folderService;
 
     @Autowired
     private FolderRepository folderRepository;
@@ -94,7 +94,7 @@ public void setUp() {
                 Provider.KAKAO
         );
 
-        FolderResponse folderResponse = folderService.createFolderForPersonal(member.getId(), "newServiceTestFolder");
+        FolderResponse folderResponse = folderService.createFolder(member.getId(), "newServiceTestFolder");
         newsFolderId = folderResponse.folderId();
 
         Folder folder = folderRepository.findById(folderResponse.folderId()).orElse(null);
diff --git a/src/test/java/org/tuna/zoopzoop/backend/domain/space/archive/controller/SpaceArchiveFolderControllerTest.java b/src/test/java/org/tuna/zoopzoop/backend/domain/space/archive/controller/SpaceArchiveFolderControllerTest.java
new file mode 100644
index 00000000..63ff5c95
--- /dev/null
+++ b/src/test/java/org/tuna/zoopzoop/backend/domain/space/archive/controller/SpaceArchiveFolderControllerTest.java
@@ -0,0 +1,385 @@
+package org.tuna.zoopzoop.backend.domain.space.archive.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.MediaType;
+import org.springframework.security.test.context.support.WithUserDetails;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.transaction.annotation.Transactional;
+import org.tuna.zoopzoop.backend.domain.archive.folder.dto.reqBodyForCreateFolder;
+import org.tuna.zoopzoop.backend.domain.archive.folder.entity.Folder;
+import org.tuna.zoopzoop.backend.domain.archive.folder.repository.FolderRepository;
+import org.tuna.zoopzoop.backend.domain.datasource.entity.Category;
+import org.tuna.zoopzoop.backend.domain.datasource.entity.DataSource;
+import org.tuna.zoopzoop.backend.domain.datasource.entity.Tag;
+import org.tuna.zoopzoop.backend.domain.datasource.repository.DataSourceRepository;
+import org.tuna.zoopzoop.backend.domain.member.entity.Member;
+import org.tuna.zoopzoop.backend.domain.member.enums.Provider;
+import org.tuna.zoopzoop.backend.domain.member.repository.MemberRepository;
+import org.tuna.zoopzoop.backend.domain.member.service.MemberService;
+import org.tuna.zoopzoop.backend.domain.space.membership.enums.Authority;
+import org.tuna.zoopzoop.backend.domain.space.membership.service.MembershipService;
+import org.tuna.zoopzoop.backend.domain.space.space.entity.Space;
+import org.tuna.zoopzoop.backend.domain.space.space.service.SpaceService;
+import org.tuna.zoopzoop.backend.global.jpa.entity.BaseEntity;
+
+import java.time.LocalDate;
+import java.util.List;
+
+import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@ActiveProfiles("test")
+@SpringBootTest
+@AutoConfigureMockMvc
+@Transactional
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class SpaceArchiveFolderControllerTest {
+
+    @Autowired private MockMvc mockMvc;
+    @Autowired private ObjectMapper objectMapper;
+
+    @Autowired private MemberService memberService;
+    @Autowired private MemberRepository memberRepository;
+
+    @Autowired private SpaceService spaceService;
+    @Autowired private MembershipService membershipService;
+
+    @Autowired private FolderRepository folderRepository;
+    @Autowired private DataSourceRepository dataSourceRepository;
+
+    private static final String OWNER_PK = "sp1111";
+    private static final String READER_PK = "sp2222";
+
+    private Integer ownerMemberId;
+    private Integer readerMemberId;
+
+    private Integer spaceId;
+    private Integer defaultFolderId;
+    private Integer docsFolderId;
+
+    @BeforeAll
+    void setUp() {
+        // 사용자 생성
+        try { memberService.createMember("spaceOwner", "http://img/owner.png", OWNER_PK, Provider.KAKAO); } catch (Exception ignored) {}
+        try { memberService.createMember("spaceReader", "http://img/reader.png", READER_PK, Provider.KAKAO); } catch (Exception ignored) {}
+
+        ownerMemberId = memberRepository.findByProviderAndProviderKey(Provider.KAKAO, OWNER_PK)
+                .map(BaseEntity::getId).orElseThrow();
+        readerMemberId = memberRepository.findByProviderAndProviderKey(Provider.KAKAO, READER_PK)
+                .map(BaseEntity::getId).orElseThrow();
+
+        Member owner = memberRepository.findById(ownerMemberId).orElseThrow();
+        Member reader = memberRepository.findById(readerMemberId).orElseThrow();
+
+        // 스페이스 생성 + 멤버십 부여
+        Space space = spaceService.createSpace("space-folder-test");
+        spaceId = space.getId();
+
+        membershipService.addMemberToSpace(owner, space, Authority.ADMIN);
+        membershipService.addMemberToSpace(reader, space, Authority.READ_ONLY);
+
+        // 공유 아카이브의 default 폴더 직접 생성
+        // 공유 아카이브의 default 폴더 idempotent 생성
+        var archive = space.getSharingArchive().getArchive();
+
+        Folder defaultFolder = folderRepository.findByArchiveIdAndIsDefaultTrue(archive.getId())
+                .orElseGet(() -> {
+                    Folder f = new Folder("default");
+                    f.setArchive(archive);
+                    f.setDefault(true);
+                    return folderRepository.saveAndFlush(f);
+                });
+        defaultFolderId = defaultFolder.getId();
+
+        Folder docsFolder = folderRepository.findByArchiveIdAndName(archive.getId(), "docs")
+                .orElseGet(() -> {
+                    Folder f = new Folder();
+                    f.setArchive(archive);
+                    f.setName("docs");
+                    f.setDefault(false);
+                    return folderRepository.saveAndFlush(f);
+                });
+        docsFolderId = docsFolder.getId();
+
+
+        DataSource d1 = new DataSource();
+        d1.setFolder(docsFolder);
+        d1.setTitle("spec.pdf");
+        d1.setSummary("요약 A");
+        d1.setSourceUrl("http://src/a");
+        d1.setImageUrl("http://img/a");
+        d1.setDataCreatedDate(LocalDate.now());
+        d1.setActive(true);
+        d1.setTags(List.of(new Tag("tag1"), new Tag("tag2")));
+        d1.setCategory(Category.IT);
+        dataSourceRepository.save(d1);
+
+        DataSource d2 = new DataSource();
+        d2.setFolder(docsFolder);
+        d2.setTitle("notes.txt");
+        d2.setSummary("요약 B");
+        d2.setSourceUrl("http://src/b");
+        d2.setImageUrl("http://img/b");
+        d2.setDataCreatedDate(LocalDate.now());
+        d2.setActive(true);
+        d2.setTags(List.of());
+        d2.setCategory(Category.SCIENCE);
+        dataSourceRepository.save(d2);
+    }
+
+    @AfterAll
+    void tearDown() {
+        try {
+            if (docsFolderId != null) {
+                dataSourceRepository.deleteAll(dataSourceRepository.findAllByFolderId(docsFolderId));
+            }
+        } catch (Exception ignored) {}
+    }
+
+    // ---------- Create ----------
+    @Test
+    @DisplayName("공유 아카이브 폴더 생성 - 성공 시 200과 응답 DTO 반환")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void createFolder_ok() throws Exception {
+        var req = new reqBodyForCreateFolder("보고서");
+
+        mockMvc.perform(post("/api/v1/spaces/{spaceId}/archive/folder", spaceId)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(req)))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("200"))
+                .andExpect(jsonPath("$.msg").value("보고서 폴더가 생성되었습니다."))
+                .andExpect(jsonPath("$.data.folderId").isNumber())
+                .andExpect(jsonPath("$.data.folderName").value("보고서"));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 생성 - 폴더 이름 누락 시 400")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void createFolder_missingName() throws Exception {
+        var req = new reqBodyForCreateFolder(null);
+
+        mockMvc.perform(post("/api/v1/spaces/{spaceId}/archive/folder", spaceId)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(req)))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.status").value("400"));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 생성 실패 - 스페이스 구성원이 아니면 403")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void createFolder_notMember_forbidden() {
+        var req = new reqBodyForCreateFolder("x");
+        int otherSpaceId = 999999;
+        // 존재하지 않으면 404인데, 여기서는 멤버십 실패를 보기 위해 우선 spaceId 그대로 두고 아래 테스트로 대체
+        // 실제로 멤버십 실패를 정확히 보려면 별도 스페이스를 생성하되 owner를 초대하지 않는 방법이 필요
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 생성 실패 - 권한 없음(READ_ONLY) 403")
+    @WithUserDetails("KAKAO:" + READER_PK)
+    void createFolder_noAuthority_forbidden() throws Exception {
+        var req = new reqBodyForCreateFolder("읽기전용은못만듦");
+
+        mockMvc.perform(post("/api/v1/spaces/{spaceId}/archive/folder", spaceId)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(req)))
+                .andExpect(status().isForbidden())
+                .andExpect(jsonPath("$.status").value("403"))
+                .andExpect(jsonPath("$.msg").value("폴더 생성 권한이 없습니다."));
+    }
+
+    // ---------- Delete ----------
+    @Test
+    @DisplayName("공유 아카이브 폴더 삭제 - 성공 시 200과 삭제 메시지 반환")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void deleteFolder_ok() throws Exception {
+        var req = new reqBodyForCreateFolder("todelete");
+        String content = objectMapper.writeValueAsString(req);
+        var createRes = mockMvc.perform(post("/api/v1/spaces/{spaceId}/archive/folder", spaceId)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(content))
+                .andReturn().getResponse().getContentAsString();
+
+        Integer toDelete = folderRepository.findByArchiveIdAndName(
+                folderRepository.findAll().stream().filter(f -> "todelete".equals(f.getName())).findFirst().orElseThrow().getArchive().getId(),
+                "todelete"
+        ).orElseThrow().getId();
+
+        mockMvc.perform(delete("/api/v1/spaces/{spaceId}/archive/folder/{folderId}", spaceId, toDelete))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("200"))
+                .andExpect(jsonPath("$.msg").value("todelete 폴더가 삭제됐습니다."))
+                .andExpect(jsonPath("$.data").value(nullValue()));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 삭제 실패 - 기본 폴더면 400")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void deleteDefaultFolder_badRequest() throws Exception {
+        mockMvc.perform(delete("/api/v1/spaces/{spaceId}/archive/folder/{folderId}", spaceId, 0))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.status").value("400"))
+                .andExpect(jsonPath("$.msg").value("default 폴더는 삭제할 수 없습니다."))
+                .andExpect(jsonPath("$.data").value(nullValue()));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 삭제 실패 - 권한 없음(READ_ONLY) 403")
+    @WithUserDetails("KAKAO:" + READER_PK)
+    void deleteFolder_noAuthority_forbidden() throws Exception {
+        mockMvc.perform(delete("/api/v1/spaces/{spaceId}/archive/folder/{folderId}", spaceId, docsFolderId))
+                .andExpect(status().isForbidden())
+                .andExpect(jsonPath("$.status").value("403"))
+                .andExpect(jsonPath("$.msg").value("폴더 삭제 권한이 없습니다."));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 삭제 실패 - 폴더가 없으면 404")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void deleteFolder_notFound() throws Exception {
+        mockMvc.perform(delete("/api/v1/spaces/{spaceId}/archive/folder/{folderId}", spaceId, 999999))
+                .andExpect(status().isNotFound())
+                .andExpect(jsonPath("$.status").value("404"))
+                .andExpect(jsonPath("$.msg").value("존재하지 않는 폴더입니다."));
+    }
+
+    // ---------- Update ----------
+    @Test
+    @DisplayName("공유 아카이브 폴더 이름 변경 - 성공 시 200과 변경된 이름 반환")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void updateFolder_ok() throws Exception {
+        var body = new java.util.HashMap<String, String>();
+        body.put("folderName", "회의록");
+
+        mockMvc.perform(patch("/api/v1/spaces/{spaceId}/archive/folder/{folderId}", spaceId, docsFolderId)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(body)))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("200"))
+                .andExpect(jsonPath("$.msg").value("폴더 이름이 회의록(으)로 변경됐습니다."))
+                .andExpect(jsonPath("$.data.folderName").value("회의록"));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 이름 변경 실패 - 기본 폴더면 400")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void updateDefaultFolder_badRequest() throws Exception {
+        var body = new java.util.HashMap<String, String>();
+        body.put("folderName", "무시됨");
+
+        mockMvc.perform(patch("/api/v1/spaces/{spaceId}/archive/folder/{folderId}", spaceId, 0)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(body)))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.status").value("400"))
+                .andExpect(jsonPath("$.msg").value("default 폴더는 이름을 변경할 수 없습니다."))
+                .andExpect(jsonPath("$.data").value(nullValue()));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 이름 변경 실패 - 권한 없음(READ_ONLY) 403")
+    @WithUserDetails("KAKAO:" + READER_PK)
+    void updateFolder_noAuthority() throws Exception {
+        var body = new java.util.HashMap<String, String>();
+        body.put("folderName", "변경불가");
+
+        mockMvc.perform(patch("/api/v1/spaces/{spaceId}/archive/folder/{folderId}", spaceId, docsFolderId)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(body)))
+                .andExpect(status().isForbidden())
+                .andExpect(jsonPath("$.status").value("403"))
+                .andExpect(jsonPath("$.msg").value("폴더 수정 권한이 없습니다."));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 이름 변경 실패 - 폴더가 없으면 404")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void updateFolder_notFound() throws Exception {
+        var body = new java.util.HashMap<String, String>();
+        body.put("folderName", "어딨니");
+
+        mockMvc.perform(patch("/api/v1/spaces/{spaceId}/archive/folder/{folderId}", spaceId, 999999)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(body)))
+                .andExpect(status().isNotFound())
+                .andExpect(jsonPath("$.status").value("404"))
+                .andExpect(jsonPath("$.msg").value("존재하지 않는 폴더입니다."));
+    }
+
+    // ---------- Read ----------
+    @Test
+    @DisplayName("공유 아카이브 폴더 목록 조회 - 성공")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void listFolders_success() throws Exception {
+        mockMvc.perform(get("/api/v1/spaces/{spaceId}/archive/folder", spaceId)
+                        .accept(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("200"))
+                .andExpect(jsonPath("$.msg").value("공유 아카이브의 폴더 목록이 조회되었습니다."))
+                .andExpect(jsonPath("$.data").isArray());
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 목록 조회 실패 - 읽기 권한 없으면 403")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void listFolders_forbidden_when_not_member() throws Exception {
+        Space other = spaceService.createSpace("no-membership-space");
+        Integer otherSpaceId = other.getId();
+
+        mockMvc.perform(get("/api/v1/spaces/{spaceId}/archive/folder", otherSpaceId)
+                        .accept(MediaType.APPLICATION_JSON))
+                .andExpect(status().isForbidden())
+                .andExpect(jsonPath("$.status").value("403"))
+                .andExpect(jsonPath("$.msg").value("스페이스의 구성원이 아닙니다."));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 특정 폴더 내 파일 목록 조회 - 성공")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void filesInFolder_success() throws Exception {
+        mockMvc.perform(get("/api/v1/spaces/{spaceId}/archive/folder/{folderId}/files", spaceId, docsFolderId)
+                        .accept(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("200"))
+                .andExpect(jsonPath("$.msg").value("폴더 안의 파일 목록을 불러왔습니다."))
+                .andExpect(jsonPath("$.data.folderId").value(docsFolderId))
+                .andExpect(jsonPath("$.data.folderName").isString())
+                .andExpect(jsonPath("$.data.files").isArray())
+                .andExpect(jsonPath("$.data.files.length()").value(greaterThanOrEqualTo(2)));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 기본 폴더 내 파일 목록 조회 - 성공")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void filesInDefaultFolder_success() throws Exception {
+        mockMvc.perform(get("/api/v1/spaces/{spaceId}/archive/folder/{folderId}/files", spaceId, 0)
+                        .accept(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("200"))
+                .andExpect(jsonPath("$.msg").value("폴더 안의 파일 목록을 불러왔습니다."))
+                .andExpect(jsonPath("$.data.folderId").isNumber())
+                .andExpect(jsonPath("$.data.folderName").isString())
+                .andExpect(jsonPath("$.data.files").isArray());
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 내 파일 목록 조회 실패 - 폴더가 없으면 404")
+    @WithUserDetails("KAKAO:" + OWNER_PK)
+    void filesInFolder_notFound() throws Exception {
+        mockMvc.perform(get("/api/v1/spaces/{spaceId}/archive/folder/{folderId}/files", spaceId, 999999)
+                        .accept(MediaType.APPLICATION_JSON))
+                .andExpect(status().isNotFound())
+                .andExpect(jsonPath("$.status").value("404"))
+                .andExpect(jsonPath("$.msg").value("존재하지 않는 폴더입니다."));
+    }
+}
diff --git a/src/test/java/org/tuna/zoopzoop/backend/domain/space/archive/service/SpaceArchiveFolderServiceTest.java b/src/test/java/org/tuna/zoopzoop/backend/domain/space/archive/service/SpaceArchiveFolderServiceTest.java
new file mode 100644
index 00000000..5a35865a
--- /dev/null
+++ b/src/test/java/org/tuna/zoopzoop/backend/domain/space/archive/service/SpaceArchiveFolderServiceTest.java
@@ -0,0 +1,395 @@
+package org.tuna.zoopzoop.backend.domain.space.archive.service;
+
+import jakarta.persistence.NoResultException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.tuna.zoopzoop.backend.domain.archive.archive.entity.Archive;
+import org.tuna.zoopzoop.backend.domain.archive.archive.entity.SharingArchive;
+import org.tuna.zoopzoop.backend.domain.archive.folder.dto.FolderResponse;
+import org.tuna.zoopzoop.backend.domain.archive.folder.service.FolderService;
+import org.tuna.zoopzoop.backend.domain.datasource.dto.FolderFilesDto;
+import org.tuna.zoopzoop.backend.domain.member.entity.Member;
+import org.tuna.zoopzoop.backend.domain.space.membership.entity.Membership;
+import org.tuna.zoopzoop.backend.domain.space.membership.enums.Authority;
+import org.tuna.zoopzoop.backend.domain.space.membership.service.MembershipService;
+import org.tuna.zoopzoop.backend.domain.space.space.entity.Space;
+import org.tuna.zoopzoop.backend.domain.space.space.service.SpaceService;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class SpaceArchiveFolderServiceTest {
+
+    @Mock private SpaceService spaceService;
+    @Mock private MembershipService membershipService;
+    @Mock private FolderService folderService;
+
+    @InjectMocks private SpaceArchiveFolderService spaceArchiveFolderService;
+
+    // --------- helpers ---------
+    private Member requester() {
+        Member m = new Member();
+        ReflectionTestUtils.setField(m, "id", 7);
+        return m;
+    }
+
+    private Space spaceWithArchive(int spaceId) {
+        Space s = new Space();
+        ReflectionTestUtils.setField(s, "id", spaceId);
+
+        SharingArchive sa = new SharingArchive();
+        Archive a = new Archive();
+        ReflectionTestUtils.setField(a, "id", 999);
+        sa.setArchive(a);
+        sa.setSpace(s);
+
+        s.setSharingArchive(sa);
+        return s;
+    }
+
+    private Membership membership(Authority auth) {
+        Membership ms = new Membership();
+        ms.setAuthority(auth);
+        return ms;
+    }
+
+    // ---------------------- Create ----------------------
+    @Test
+    @DisplayName("공유 아카이브 폴더 생성 성공 - 권한 있음")
+    void createFolder_success() {
+        Integer spaceId = 1;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(true);
+        when(membershipService.findByMemberAndSpace(req, space)).thenReturn(membership(Authority.ADMIN));
+        when(folderService.createFolder(any(Archive.class), eq("보고서")))
+                .thenReturn(new FolderResponse("보고서", 123));
+
+        FolderResponse rs = spaceArchiveFolderService.createFolder(spaceId, req, "보고서");
+
+        assertThat(rs.folderName()).isEqualTo("보고서");
+        assertThat(rs.folderId()).isEqualTo(123);
+        verify(folderService).createFolder(eq(space.getSharingArchive().getArchive()), eq("보고서"));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 생성 실패 - 스페이스 없음")
+    void createFolder_spaceNotFound() {
+        Integer spaceId = 999;
+        Member req = requester();
+
+        when(spaceService.findById(spaceId)).thenThrow(new NoResultException("존재하지 않는 스페이스입니다."));
+
+        assertThrows(NoResultException.class,
+                () -> spaceArchiveFolderService.createFolder(spaceId, req, "보고서"));
+        verifyNoInteractions(folderService);
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 생성 실패 - 구성원 아님")
+    void createFolder_notMember() {
+        Integer spaceId = 1;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(false);
+
+        assertThrows(SecurityException.class,
+                () -> spaceArchiveFolderService.createFolder(spaceId, req, "보고서"));
+        verifyNoInteractions(folderService);
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 생성 실패 - 권한 없음 (PENDING/READ_ONLY)")
+    void createFolder_noAuthority() {
+        Integer spaceId = 1;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(true);
+        when(membershipService.findByMemberAndSpace(req, space)).thenReturn(membership(Authority.READ_ONLY));
+
+        assertThrows(SecurityException.class,
+                () -> spaceArchiveFolderService.createFolder(spaceId, req, "보고서"));
+        verifyNoInteractions(folderService);
+    }
+
+    // ---------------------- Delete ----------------------
+    @Test
+    @DisplayName("공유 아카이브 폴더 삭제 성공")
+    void deleteFolder_success() {
+        Integer spaceId = 1, folderId = 10;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(true);
+        when(membershipService.findByMemberAndSpace(req, space)).thenReturn(membership(Authority.ADMIN));
+        when(folderService.deleteFolder(space.getSharingArchive().getArchive(), folderId))
+                .thenReturn("docs");
+
+        String deleted = spaceArchiveFolderService.deleteFolder(spaceId, req, folderId);
+
+        assertThat(deleted).isEqualTo("docs");
+        verify(folderService).deleteFolder(eq(space.getSharingArchive().getArchive()), eq(folderId));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 삭제 실패 - 권한 없음")
+    void deleteFolder_noAuthority() {
+        Integer spaceId = 1, folderId = 10;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(true);
+        when(membershipService.findByMemberAndSpace(req, space)).thenReturn(membership(Authority.READ_ONLY));
+
+        assertThrows(SecurityException.class,
+                () -> spaceArchiveFolderService.deleteFolder(spaceId, req, folderId));
+        verifyNoInteractions(folderService);
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 삭제 실패 - 존재하지 않는 폴더(공통 서비스 예외 전파)")
+    void deleteFolder_notFound() {
+        Integer spaceId = 1, folderId = 999;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(true);
+        when(membershipService.findByMemberAndSpace(req, space)).thenReturn(membership(Authority.ADMIN));
+        when(folderService.deleteFolder(space.getSharingArchive().getArchive(), folderId))
+                .thenThrow(new NoResultException("존재하지 않는 폴더입니다."));
+
+        assertThrows(NoResultException.class,
+                () -> spaceArchiveFolderService.deleteFolder(spaceId, req, folderId));
+        verify(folderService).deleteFolder(eq(space.getSharingArchive().getArchive()), eq(folderId));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 삭제 실패 - 기본 폴더는 삭제 불가(공통 서비스 예외 전파)")
+    void deleteFolder_defaultForbidden() {
+        Integer spaceId = 1, folderId = 0;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(true);
+        when(membershipService.findByMemberAndSpace(req, space)).thenReturn(membership(Authority.ADMIN));
+        when(folderService.deleteFolder(space.getSharingArchive().getArchive(), folderId))
+                .thenThrow(new IllegalArgumentException("default 폴더는 삭제할 수 없습니다."));
+
+        assertThrows(IllegalArgumentException.class,
+                () -> spaceArchiveFolderService.deleteFolder(spaceId, req, folderId));
+        verify(folderService).deleteFolder(eq(space.getSharingArchive().getArchive()), eq(folderId));
+    }
+
+    // ---------------------- Update ----------------------
+    @Test
+    @DisplayName("공유 아카이브 폴더 이름 변경 성공")
+    void updateFolderName_success() {
+        Integer spaceId = 1, folderId = 22;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(true);
+        when(membershipService.findByMemberAndSpace(req, space)).thenReturn(membership(Authority.ADMIN));
+        when(folderService.updateFolderName(space.getSharingArchive().getArchive(), folderId, "새이름"))
+                .thenReturn("새이름");
+
+        String updated = spaceArchiveFolderService.updateFolderName(spaceId, req, folderId, "새이름");
+
+        assertThat(updated).isEqualTo("새이름");
+        verify(folderService).updateFolderName(eq(space.getSharingArchive().getArchive()), eq(folderId), eq("새이름"));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 이름 변경 실패 - 중복 이름 존재(공통 서비스 예외 전파)")
+    void updateFolderName_conflict() {
+        Integer spaceId = 1, folderId = 22;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(true);
+        when(membershipService.findByMemberAndSpace(req, space)).thenReturn(membership(Authority.ADMIN));
+        when(folderService.updateFolderName(space.getSharingArchive().getArchive(), folderId, "보고서"))
+                .thenThrow(new IllegalArgumentException("이미 존재하는 폴더명입니다."));
+
+        assertThrows(IllegalArgumentException.class,
+                () -> spaceArchiveFolderService.updateFolderName(spaceId, req, folderId, "보고서"));
+        verify(folderService).updateFolderName(eq(space.getSharingArchive().getArchive()), eq(folderId), eq("보고서"));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 이름 변경 실패 - 폴더 없음(공통 서비스 예외 전파)")
+    void updateFolderName_notFound() {
+        Integer spaceId = 1, folderId = 22;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(true);
+        when(membershipService.findByMemberAndSpace(req, space)).thenReturn(membership(Authority.ADMIN));
+        when(folderService.updateFolderName(space.getSharingArchive().getArchive(), folderId, "새이름"))
+                .thenThrow(new NoResultException("존재하지 않는 폴더입니다."));
+
+        assertThrows(NoResultException.class,
+                () -> spaceArchiveFolderService.updateFolderName(spaceId, req, folderId, "새이름"));
+        verify(folderService).updateFolderName(eq(space.getSharingArchive().getArchive()), eq(folderId), eq("새이름"));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 이름 변경 실패 - 권한 없음")
+    void updateFolderName_noAuthority() {
+        Integer spaceId = 1, folderId = 22;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberJoinedSpace(req, space)).thenReturn(true);
+        when(membershipService.findByMemberAndSpace(req, space)).thenReturn(membership(Authority.READ_ONLY));
+
+        assertThrows(SecurityException.class,
+                () -> spaceArchiveFolderService.updateFolderName(spaceId, req, folderId, "새이름"));
+        verifyNoInteractions(folderService);
+    }
+
+    // ---------------------- Read: 목록/파일 ----------------------
+    @Test
+    @DisplayName("공유 아카이브 폴더 목록 조회 성공")
+    void getFolders_success() {
+        Integer spaceId = 1;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberInSpace(req, space)).thenReturn(true);
+        when(folderService.getFolders(space.getSharingArchive().getArchive()))
+                .thenReturn(List.of(new FolderResponse("default", 1), new FolderResponse("docs", 2)));
+
+        List<FolderResponse> rs = spaceArchiveFolderService.getFolders(spaceId, req);
+
+        assertThat(rs).hasSize(2);
+        assertThat(rs.getFirst().folderName()).isEqualTo("default");
+        verify(folderService).getFolders(eq(space.getSharingArchive().getArchive()));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 목록 조회 실패 - 권한 없음")
+    void getFolders_noAuthority() {
+        Integer spaceId = 1;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberInSpace(req, space)).thenReturn(false);
+
+        assertThrows(SecurityException.class,
+                () -> spaceArchiveFolderService.getFolders(spaceId, req));
+        verifyNoInteractions(folderService);
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 특정 폴더 내 파일 목록 조회 성공")
+    void getFilesInFolder_success() {
+        Integer spaceId = 1, folderId = 50;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+        FolderFilesDto dto = new FolderFilesDto(folderId, "docs", List.of());
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberInSpace(req, space)).thenReturn(true);
+        when(folderService.getFilesInFolder(space.getSharingArchive().getArchive(), folderId)).thenReturn(dto);
+
+        FolderFilesDto rs = spaceArchiveFolderService.getFilesInFolder(spaceId, req, folderId);
+
+        assertThat(rs.folderId()).isEqualTo(folderId);
+        assertThat(rs.folderName()).isEqualTo("docs");
+        verify(folderService).getFilesInFolder(eq(space.getSharingArchive().getArchive()), eq(folderId));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 내 파일 목록 조회 실패 - 폴더 없음(공통 서비스 예외 전파)")
+    void getFilesInFolder_notFound() {
+        Integer spaceId = 1, folderId = 404;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberInSpace(req, space)).thenReturn(true);
+        when(folderService.getFilesInFolder(space.getSharingArchive().getArchive(), folderId))
+                .thenThrow(new NoResultException("존재하지 않는 폴더입니다."));
+
+        assertThrows(NoResultException.class,
+                () -> spaceArchiveFolderService.getFilesInFolder(spaceId, req, folderId));
+        verify(folderService).getFilesInFolder(eq(space.getSharingArchive().getArchive()), eq(folderId));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 폴더 내 파일 목록 조회 실패 - 권한 없음")
+    void getFilesInFolder_noAuthority() {
+        Integer spaceId = 1, folderId = 50;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberInSpace(req, space)).thenReturn(false);
+
+        assertThrows(SecurityException.class,
+                () -> spaceArchiveFolderService.getFilesInFolder(spaceId, req, folderId));
+        verifyNoInteractions(folderService);
+    }
+
+    // ---------------------- Read: default ID ----------------------
+    @Test
+    @DisplayName("공유 아카이브 default 폴더 ID 조회 성공")
+    void getDefaultFolderId_success() {
+        Integer spaceId = 1;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberInSpace(req, space)).thenReturn(true);
+        when(folderService.getDefaultFolderId(space.getSharingArchive().getArchive()))
+                .thenReturn(42);
+
+        Integer id = spaceArchiveFolderService.getDefaultFolderId(spaceId, req);
+
+        assertThat(id).isEqualTo(42);
+        verify(folderService).getDefaultFolderId(eq(space.getSharingArchive().getArchive()));
+    }
+
+    @Test
+    @DisplayName("공유 아카이브 default 폴더 ID 조회 실패 - 권한 없음")
+    void getDefaultFolderId_noAuthority() {
+        Integer spaceId = 1;
+        Member req = requester();
+        Space space = spaceWithArchive(spaceId);
+
+        when(spaceService.findById(spaceId)).thenReturn(space);
+        when(membershipService.isMemberInSpace(req, space)).thenReturn(false);
+
+        assertThrows(SecurityException.class,
+                () -> spaceArchiveFolderService.getDefaultFolderId(spaceId, req));
+        verifyNoInteractions(folderService);
+    }
+}