From 89482d854f72dfeb10f3164f844de38ba887fef7 Mon Sep 17 00:00:00 2001
From: HeungTak Lee <htlee@gcsc.co.kr>
Date: Tue, 20 Jan 2026 13:38:31 +0900
Subject: [PATCH] feat: Add V2 REST API with WebSocket-compatible responses

- Add GisControllerV2/GisServiceV2 for CompactVesselTrack responses
- Add nationalCode and shipKindCode fields to REST API responses
- Add flexible DateTime parsing support (multiple formats)
- Add TrackConverter utility for track data conversion
- Update SwaggerConfig with V2 API endpoints and unified tags
- Update ProdDataSourceConfig for prod-mpr profile support
- Enhance Swagger documentation for all DTOs
---
 .../VesselPositionCacheRefreshScheduler.java  |   10 +-
 .../batch/job/VesselTrackStepConfig.java      |  125 +-
 .../batch/reader/VesselDataReader.java        |   30 +-
 .../batch/writer/VesselTrackBulkWriter.java   |  100 +-
 .../domain/debug/DebugTimeController.java     |   13 +-
 .../domain/gis/controller/GisController.java  |    2 +-
 .../gis/controller/GisControllerV2.java       |  207 ++
 .../domain/gis/dto/GisBoundaryResponse.java   |   24 +-
 .../gis/dto/TileAggregationRequest.java       |   26 +
 .../domain/gis/service/GisService.java        |   21 +-
 .../domain/gis/service/GisServiceV2.java      |  370 ++++
 .../passage/dto/SequentialPassageRequest.java |   28 +-
 .../SequentialAreaTrackingService.java        |    8 +-
 .../ship/controller/ShipImageController.java  |   56 +
 .../domain/ship/dto/ShipImageDto.java         |   18 +
 .../ship/repository/ShipImageRepository.java  |   58 +
 .../domain/ship/service/ShipImageService.java |   58 +
 .../controller/AbnormalTrackController.java   |   64 +-
 .../domain/vessel/dto/CompactVesselTrack.java |  103 +-
 .../domain/vessel/dto/IntegrationVessel.java  |    2 +-
 .../vessel/dto/RecentVesselPositionDto.java   |   49 +-
 .../domain/vessel/dto/TrackResponse.java      |   33 +-
 .../vessel/dto/VesselBucketPositionDto.java   |   56 +
 .../vessel/dto/VesselStatsResponse.java       |   13 +-
 .../vessel/dto/VesselTracksRequest.java       |   53 +-
 .../service/IntegrationVesselService.java     |    2 +-
 .../service/VesselPreviousBucketCache.java    |  303 +++
 .../global/config/BatchConfig.java            |   50 +-
 .../global/config/CacheConfig.java            |   53 +-
 .../config/DataSourceConfigProperties.java    |    2 +-
 .../FlexibleLocalDateTimeDeserializer.java    |   47 +
 .../global/config/ProdDataSourceConfig.java   |    2 +-
 .../global/config/SwaggerConfig.java          |   51 +-
 .../global/util/DateTimeParseUtil.java        |  176 ++
 .../global/util/PartitionManager.java         |  152 +-
 .../global/util/ShipKindCodeConverter.java    |   79 +-
 .../global/util/TrackConverter.java           |  231 +++
 .../util/VesselTrackDataJobListener.java      |   16 +-
 .../service/ChunkedTrackStreamingService.java |   24 +-
 .../controller/BatchAdminController.java      |   40 +-
 .../controller/DataSourceDebugController.java |    5 +
 .../controller/MetricsController.java         |   11 +-
 .../controller/MigrationController.java       |   24 +-
 .../controller/MonitoringController.java      |    7 +
 .../WebSocketMonitoringController.java        |   10 +-
 .../service/BatchMetadataCleanupService.java  |    2 +
 src/main/resources/application-dev.yml        |    9 +
 src/main/resources/application-local.yml      |   70 +-
 src/main/resources/application-prod-mpr.yml   |  278 +++
 src/main/resources/application-prod.yml       |   31 +-
 src/main/resources/application.yml            |   25 +-
 .../resources/static/admin/batch-admin.html   |  198 +-
 src/main/resources/static/gis-monitoring.html | 1594 ++------------
 .../resources/static/js/gis-monitoring.js     | 1831 +++++++++++++++++
 .../static/v2/pages/chunked-streaming.html    |    6 +-
 .../static/v2/pages/gis-monitoring.html       |   10 +-
 .../chunked-streaming-gis-animated.html       |    6 +-
 .../websocket/WebSocketLoadTest.java          |   14 +-
 58 files changed, 5018 insertions(+), 1868 deletions(-)
 create mode 100644 src/main/java/gc/mda/signal_batch/domain/gis/controller/GisControllerV2.java
 create mode 100644 src/main/java/gc/mda/signal_batch/domain/gis/service/GisServiceV2.java
 create mode 100644 src/main/java/gc/mda/signal_batch/domain/ship/controller/ShipImageController.java
 create mode 100644 src/main/java/gc/mda/signal_batch/domain/ship/dto/ShipImageDto.java
 create mode 100644 src/main/java/gc/mda/signal_batch/domain/ship/repository/ShipImageRepository.java
 create mode 100644 src/main/java/gc/mda/signal_batch/domain/ship/service/ShipImageService.java
 create mode 100644 src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselBucketPositionDto.java
 create mode 100644 src/main/java/gc/mda/signal_batch/domain/vessel/service/VesselPreviousBucketCache.java
 create mode 100644 src/main/java/gc/mda/signal_batch/global/config/FlexibleLocalDateTimeDeserializer.java
 create mode 100644 src/main/java/gc/mda/signal_batch/global/util/DateTimeParseUtil.java
 create mode 100644 src/main/java/gc/mda/signal_batch/global/util/TrackConverter.java
 create mode 100644 src/main/resources/application-prod-mpr.yml
 create mode 100644 src/main/resources/static/js/gis-monitoring.js

diff --git a/src/main/java/gc/mda/signal_batch/batch/job/VesselPositionCacheRefreshScheduler.java b/src/main/java/gc/mda/signal_batch/batch/job/VesselPositionCacheRefreshScheduler.java
index 3edac93..19f08f6 100644
--- a/src/main/java/gc/mda/signal_batch/batch/job/VesselPositionCacheRefreshScheduler.java
+++ b/src/main/java/gc/mda/signal_batch/batch/job/VesselPositionCacheRefreshScheduler.java
@@ -8,6 +8,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Profile;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.RowMapper;
 import org.springframework.scheduling.annotation.Scheduled;
@@ -40,6 +41,7 @@ import java.util.List;
  */
 @Slf4j
 @Component
+@Profile("!query")  // query 프로파일에서는 캐시 갱신 스케줄러 비활성화
 @RequiredArgsConstructor
 @ConditionalOnProperty(name = "vessel.batch.cache.latest-position.enabled", havingValue = "true", matchIfMissing = false)
 public class VesselPositionCacheRefreshScheduler {
@@ -117,7 +119,7 @@ public class VesselPositionCacheRefreshScheduler {
                 message_time as last_update
             FROM signal.sig_test
             WHERE message_time >= ? AND message_time < ?
-                AND sig_src_cd NOT IN ('000004', '000005')
+                AND sig_src_cd != '000005'
                 AND length(target_id) > 5
                 AND lat BETWEEN -90 AND 90
                 AND lon BETWEEN -180 AND 180
@@ -141,10 +143,10 @@ public class VesselPositionCacheRefreshScheduler {
     private void logCacheStats() {
         try {
             VesselLatestPositionCache.CacheStats stats = cache.getStats();
-            log.info("Cache Stats - Size: {}, HitRate: {:.2f}%, MissRate: {:.2f}%, Hits: {}, Misses: {}",
+            log.info("Cache Stats - Size: {}, HitRate: {}%, MissRate: {}%, Hits: {}, Misses: {}",
                     stats.currentSize(),
-                    stats.hitRate(),
-                    stats.missRate(),
+                    String.format("%.2f", stats.hitRate()),
+                    String.format("%.2f", stats.missRate()),
                     stats.hitCount(),
                     stats.missCount());
         } catch (Exception e) {
diff --git a/src/main/java/gc/mda/signal_batch/batch/job/VesselTrackStepConfig.java b/src/main/java/gc/mda/signal_batch/batch/job/VesselTrackStepConfig.java
index fc59235..a315588 100644
--- a/src/main/java/gc/mda/signal_batch/batch/job/VesselTrackStepConfig.java
+++ b/src/main/java/gc/mda/signal_batch/batch/job/VesselTrackStepConfig.java
@@ -2,6 +2,8 @@ package gc.mda.signal_batch.batch.job;
 
 import gc.mda.signal_batch.domain.vessel.model.VesselData;
 import gc.mda.signal_batch.domain.vessel.model.VesselTrack;
+import gc.mda.signal_batch.domain.vessel.dto.VesselBucketPositionDto;
+import gc.mda.signal_batch.domain.vessel.service.VesselPreviousBucketCache;
 import gc.mda.signal_batch.batch.processor.VesselTrackProcessor;
 import gc.mda.signal_batch.batch.processor.AbnormalTrackDetector;
 import gc.mda.signal_batch.batch.processor.AbnormalTrackDetector.AbnormalDetectionResult;
@@ -56,6 +58,10 @@ public class VesselTrackStepConfig {
     private final TrackClippingUtils trackClippingUtils;
     private final AbnormalTrackDetector abnormalTrackDetector;
     private final AbnormalTrackWriter abnormalTrackWriter;
+    private final VesselPreviousBucketCache previousBucketCache;
+
+    // 현재 처리 중인 버킷의 종료 위치 저장 (캐시 업데이트용)
+    private final Map<String, VesselBucketPositionDto> currentBucketEndPositions = new HashMap<>();
 
     public VesselTrackStepConfig(
             JobRepository jobRepository,
@@ -66,7 +72,8 @@ public class VesselTrackStepConfig {
             VesselTrackBulkWriter vesselTrackBulkWriter,
             TrackClippingUtils trackClippingUtils,
             AbnormalTrackDetector abnormalTrackDetector,
-            AbnormalTrackWriter abnormalTrackWriter) {
+            AbnormalTrackWriter abnormalTrackWriter,
+            VesselPreviousBucketCache previousBucketCache) {
         this.jobRepository = jobRepository;
         this.transactionManager = transactionManager;
         this.queryDataSource = queryDataSource;
@@ -76,6 +83,7 @@ public class VesselTrackStepConfig {
         this.trackClippingUtils = trackClippingUtils;
         this.abnormalTrackDetector = abnormalTrackDetector;
         this.abnormalTrackWriter = abnormalTrackWriter;
+        this.previousBucketCache = previousBucketCache;
     }
 
     @Value("${vessel.batch.chunk-size:1000}")
@@ -113,41 +121,112 @@ public class VesselTrackStepConfig {
             if (tracks == null || tracks.isEmpty()) {
                 return null;
             }
-            
-            // 2. 강화된 비정상 궤적 필터링
+
+            // 2. 이전 버킷 위치 조회 (캐시 + DB Fallback)
+            List<String> vesselKeys = tracks.stream()
+                    .map(track -> track.getSigSrcCd() + ":" + track.getTargetId())
+                    .distinct()
+                    .collect(Collectors.toList());
+
+            Map<String, VesselBucketPositionDto> previousPositions =
+                    previousBucketCache.getBatch(vesselKeys);
+
+            // 3. 강화된 비정상 궤적 필터링 (버킷 내 + 버킷 간 점프 검출)
             List<VesselTrack> filteredTracks = new ArrayList<>();
+
             for (VesselTrack track : tracks) {
                 boolean isAbnormal = false;
-                
+                String abnormalReason = "";
+
                 // 선박/항공기 구분
                 boolean isAircraft = "000019".equals(track.getSigSrcCd());
                 double speedLimit = isAircraft ? 300.0 : 100.0;  // 항공기 300, 선박 100
                 double distanceLimit = isAircraft ? 30.0 : 10.0; // 항공기 30nm, 선박 10nm
-                
-                // 평균속도 체크
+
+                // 버킷 내 평균속도 체크
                 if (track.getAvgSpeed() != null && track.getAvgSpeed().doubleValue() >= speedLimit) {
                     isAbnormal = true;
+                    abnormalReason = "within_bucket_speed";
                 }
-                
-                // 5분간 이동거리 체크
+
+                // 버킷 내 이동거리 체크
                 if (track.getDistanceNm() != null && track.getDistanceNm().doubleValue() >= distanceLimit) {
                     isAbnormal = true;
+                    abnormalReason = "within_bucket_distance";
                 }
-                
+
+                // 버킷 간 점프 검출 (NEW!)
+                if (!isAbnormal && track.getStartPosition() != null) {
+                    String vesselKey = track.getSigSrcCd() + ":" + track.getTargetId();
+                    VesselBucketPositionDto prevPosition = previousPositions.get(vesselKey);
+
+                    if (prevPosition != null) {
+                        double jumpDistance = calculateDistance(
+                                prevPosition.getEndLat(), prevPosition.getEndLon(),
+                                track.getStartPosition().getLat(), track.getStartPosition().getLon()
+                        );
+
+                        // 위성 AIS는 2시간, 일반 신호는 15분 범위 체크
+                        boolean isSatellite = "000016".equals(track.getSigSrcCd());
+                        double maxGapMinutes = isSatellite ? 120.0 : 15.0;
+                        double expectedMaxDistance = isAircraft ? (maxGapMinutes / 60.0 * 300.0) : (maxGapMinutes / 60.0 * 50.0);
+
+                        if (jumpDistance > expectedMaxDistance) {
+                            isAbnormal = true;
+                            abnormalReason = "bucket_to_bucket_jump";
+                            log.warn("버킷 간 점프 검출: vessel={}, jump_distance={}nm, threshold={}nm, " +
+                                    "prev_pos=[{},{}], curr_pos=[{},{}]",
+                                    vesselKey,
+                                    String.format("%.1f", jumpDistance),
+                                    String.format("%.1f", expectedMaxDistance),
+                                    String.format("%.4f", prevPosition.getEndLat()),
+                                    String.format("%.4f", prevPosition.getEndLon()),
+                                    String.format("%.4f", track.getStartPosition().getLat()),
+                                    String.format("%.4f", track.getStartPosition().getLon()));
+                        }
+                    }
+                }
+
                 if (isAbnormal) {
-                    log.warn("5분 비정상 궤적 감지: vessel={}, avg_speed={}, distance={}", 
-                        track.getVesselKey(), track.getAvgSpeed(), track.getDistanceNm());
-                    saveAbnormalTrack(track);
+                    log.warn("비정상 궤적 감지 [{}]: vessel={}, avg_speed={}, distance={}",
+                        abnormalReason, track.getVesselKey(), track.getAvgSpeed(), track.getDistanceNm());
+                    saveAbnormalTrack(track, abnormalReason);
                 } else {
                     filteredTracks.add(track);
+
+                    // 정상 궤적의 종료 위치 저장 (캐시 업데이트용)
+                    if (track.getEndPosition() != null) {
+                        String vesselKey = track.getSigSrcCd() + ":" + track.getTargetId();
+                        currentBucketEndPositions.put(vesselKey, VesselBucketPositionDto.builder()
+                                .sigSrcCd(track.getSigSrcCd())
+                                .targetId(track.getTargetId())
+                                .endLon(track.getEndPosition().getLon())
+                                .endLat(track.getEndPosition().getLat())
+                                .endTime(track.getEndPosition().getTime())
+                                .build());
+                    }
                 }
             }
-            
+
             return filteredTracks.isEmpty() ? null : filteredTracks;
         };
     }
+
+    /**
+     * Haversine 거리 계산 (해리)
+     */
+    private double calculateDistance(double lat1, double lon1, double lat2, double lon2) {
+        final double R = 3440.065; // 지구 반경 (해리)
+        double dLat = Math.toRadians(lat2 - lat1);
+        double dLon = Math.toRadians(lon2 - lon1);
+        double a = Math.sin(dLat/2) * Math.sin(dLat/2) +
+                Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) *
+                Math.sin(dLon/2) * Math.sin(dLon/2);
+        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+        return R * c;
+    }
     
-    private void saveAbnormalTrack(VesselTrack track) {
+    private void saveAbnormalTrack(VesselTrack track, String abnormalReason) {
         try {
             // Job 이름 설정
             abnormalTrackWriter.setJobName("vesselTrackAggregationJob");
@@ -220,7 +299,23 @@ public class VesselTrackStepConfig {
     @Bean
     @StepScope
     public ItemWriter<List<VesselTrack>> vesselTrackWriter() {
-        return vesselTrackBulkWriter;
+        // Bulk Writer + 캐시 업데이트를 래핑
+        return chunk -> {
+            // 1. 기존 Writer로 DB 저장
+            vesselTrackBulkWriter.write(chunk);
+
+            // 2. 캐시 업데이트 (현재 버킷 종료 위치)
+            if (!currentBucketEndPositions.isEmpty()) {
+                List<VesselBucketPositionDto> positions = new ArrayList<>(currentBucketEndPositions.values());
+                previousBucketCache.putAll(positions);
+
+                log.debug("Updated previous bucket cache with {} vessel positions",
+                        currentBucketEndPositions.size());
+
+                // 다음 청크를 위해 초기화
+                currentBucketEndPositions.clear();
+            }
+        };
     }
 
     @Bean
diff --git a/src/main/java/gc/mda/signal_batch/batch/reader/VesselDataReader.java b/src/main/java/gc/mda/signal_batch/batch/reader/VesselDataReader.java
index 74a8377..ef39105 100644
--- a/src/main/java/gc/mda/signal_batch/batch/reader/VesselDataReader.java
+++ b/src/main/java/gc/mda/signal_batch/batch/reader/VesselDataReader.java
@@ -7,6 +7,7 @@ import org.springframework.batch.item.database.JdbcPagingItemReader;
 import org.springframework.batch.item.database.Order;
 import org.springframework.batch.item.database.support.PostgresPagingQueryProvider;
 import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.RowMapper;
@@ -32,6 +33,9 @@ public class VesselDataReader {
     private final DataSource collectDataSource;
     private final JdbcTemplate collectJdbcTemplate;
 
+    @Value("${vessel.filter.zero-coordinates.enabled:false}")
+    private boolean filterZeroCoordinates;
+
     private static final DateTimeFormatter PARTITION_FORMATTER = DateTimeFormatter.ofPattern("yyMMdd");
 
     public VesselDataReader(
@@ -44,6 +48,17 @@ public class VesselDataReader {
     @PostConstruct
     public void init() {
         logDataSourceInfo();
+        log.info("Zero coordinates filter enabled: {}", filterZeroCoordinates);
+    }
+
+    /**
+     * 0 근처 좌표 필터링 조건 생성
+     */
+    private String getZeroCoordinatesFilter() {
+        if (filterZeroCoordinates) {
+            return "AND NOT (lat BETWEEN -1 AND 1 AND lon BETWEEN -1 AND 1) ";
+        }
+        return "";
     }
 
     /**
@@ -88,19 +103,20 @@ public class VesselDataReader {
         log.info("Using table: {}", tableName);
 
         // 최신 위치만 가져오는 SQL - DISTINCT ON 사용
-        String sql = """
+        String sql = String.format("""
             SELECT DISTINCT ON (sig_src_cd, target_id)
                 message_time, real_time, sig_src_cd, target_id,
                 lat, lon, sog, cog, heading, ship_nm, ship_ty, rot, posacc,
                 sensor_id, base_st_id, mode, gps_sttus, battery_sttus,
                 vts_cd, mmsi, vpass_id, ship_no
             FROM signal.%s
-            WHERE message_time >= ? AND message_time < ? 
+            WHERE message_time >= ? AND message_time < ?
                 AND sig_src_cd != '000005'
-                AND lat BETWEEN -90 AND 90 
+                AND lat BETWEEN -90 AND 90
                 AND lon BETWEEN -180 AND 180
+                %s
             ORDER BY sig_src_cd, target_id, message_time DESC
-            """.formatted(tableName);
+            """, tableName, getZeroCoordinatesFilter());
 
         reader.setSql(sql);
 
@@ -181,6 +197,7 @@ public class VesselDataReader {
         sql.append("vts_cd, mmsi, vpass_id, ship_no ");
         sql.append("FROM signal.").append(tableName).append(" ");
         sql.append("WHERE message_time >= ? AND message_time < ? AND sig_src_cd != '000005' ");
+        sql.append(getZeroCoordinatesFilter());
         sql.append("ORDER BY message_time, sig_src_cd, target_id");
 
         reader.setSql(sql.toString());
@@ -218,7 +235,10 @@ public class VesselDataReader {
                 "vts_cd, mmsi, vpass_id, ship_no ");
 
         queryProvider.setFromClause("FROM signal." + tableName);
-        queryProvider.setWhereClause("WHERE message_time >= :startTime AND message_time < :endTime and sig_src_cd != '000005'");
+
+        String whereClause = "WHERE message_time >= :startTime AND message_time < :endTime and sig_src_cd != '000005' "
+                + getZeroCoordinatesFilter();
+        queryProvider.setWhereClause(whereClause);
 
         Map<String, Order> sortKeys = new HashMap<>();
         sortKeys.put("message_time", Order.ASCENDING);
diff --git a/src/main/java/gc/mda/signal_batch/batch/writer/VesselTrackBulkWriter.java b/src/main/java/gc/mda/signal_batch/batch/writer/VesselTrackBulkWriter.java
index a60b699..dad0abf 100644
--- a/src/main/java/gc/mda/signal_batch/batch/writer/VesselTrackBulkWriter.java
+++ b/src/main/java/gc/mda/signal_batch/batch/writer/VesselTrackBulkWriter.java
@@ -108,28 +108,90 @@ public class VesselTrackBulkWriter implements ItemWriter<List<VesselTrack>> {
         }
     }
     
-    // track_geom만 사용하는 단순화된 COPY
+    // 임시 테이블 + MERGE 패턴을 사용한 Bulk Upsert
     private void bulkInsertTracks(List<VesselTrack> tracks, String tableName) throws Exception {
         try (Connection conn = queryDataSource.getConnection()) {
-            BaseConnection baseConn = conn.unwrap(BaseConnection.class);
-            CopyManager copyManager = new CopyManager(baseConn);
-            
-            String copySql = String.format("""
-                COPY %s (
-                    sig_src_cd, target_id, time_bucket, track_geom,
-                    distance_nm, avg_speed, max_speed, point_count,
-                    start_position, end_position
-                ) FROM STDIN
-            """, tableName);
-            
-            StringWriter writer = new StringWriter();
-            for (VesselTrack track : tracks) {
-                writer.write(formatTrackLine(track));
-                writer.write('\n');
+            conn.setAutoCommit(false);
+
+            try {
+                BaseConnection baseConn = conn.unwrap(BaseConnection.class);
+                CopyManager copyManager = new CopyManager(baseConn);
+
+                // 1. 임시 테이블 생성 (UNLOGGED for performance)
+                String tempTableName = "temp_vessel_tracks_" + Thread.currentThread().getId();
+                try (var stmt = conn.createStatement()) {
+                    stmt.execute(String.format("""
+                        CREATE TEMP TABLE IF NOT EXISTS %s (
+                            sig_src_cd VARCHAR(10),
+                            target_id VARCHAR(30),
+                            time_bucket TIMESTAMP,
+                            track_geom GEOMETRY,
+                            distance_nm NUMERIC,
+                            avg_speed NUMERIC,
+                            max_speed NUMERIC,
+                            point_count INTEGER,
+                            start_position JSONB,
+                            end_position JSONB
+                        ) ON COMMIT DROP
+                    """, tempTableName));
+
+                    // 임시 테이블 비우기 (이전 실행에서 남은 데이터 제거)
+                    stmt.execute("TRUNCATE " + tempTableName);
+                }
+
+                // 2. COPY로 임시 테이블에 bulk insert
+                String copySql = String.format("""
+                    COPY %s (
+                        sig_src_cd, target_id, time_bucket, track_geom,
+                        distance_nm, avg_speed, max_speed, point_count,
+                        start_position, end_position
+                    ) FROM STDIN
+                """, tempTableName);
+
+                StringWriter writer = new StringWriter();
+                for (VesselTrack track : tracks) {
+                    writer.write(formatTrackLine(track));
+                    writer.write('\n');
+                }
+
+                long rowsCopied = copyManager.copyIn(copySql, new StringReader(writer.toString()));
+
+                // 3. 임시 테이블에서 최종 테이블로 UPSERT
+                String upsertSql = String.format("""
+                    INSERT INTO %s (
+                        sig_src_cd, target_id, time_bucket, track_geom,
+                        distance_nm, avg_speed, max_speed, point_count,
+                        start_position, end_position
+                    )
+                    SELECT
+                        sig_src_cd, target_id, time_bucket, track_geom,
+                        distance_nm, avg_speed, max_speed, point_count,
+                        start_position, end_position
+                    FROM %s
+                    ON CONFLICT (sig_src_cd, target_id, time_bucket)
+                    DO UPDATE SET
+                        track_geom = EXCLUDED.track_geom,
+                        distance_nm = EXCLUDED.distance_nm,
+                        avg_speed = EXCLUDED.avg_speed,
+                        max_speed = EXCLUDED.max_speed,
+                        point_count = EXCLUDED.point_count,
+                        start_position = EXCLUDED.start_position,
+                        end_position = EXCLUDED.end_position
+                """, tableName, tempTableName);
+
+                int rowsUpserted;
+                try (var stmt = conn.createStatement()) {
+                    rowsUpserted = stmt.executeUpdate(upsertSql);
+                }
+
+                conn.commit();
+                log.info("Bulk upserted {} vessel tracks to {} (copied: {}, upserted: {})",
+                        tracks.size(), tableName, rowsCopied, rowsUpserted);
+
+            } catch (Exception e) {
+                conn.rollback();
+                throw e;
             }
-            
-            long rowsInserted = copyManager.copyIn(copySql, new StringReader(writer.toString()));
-            log.info("Bulk inserted {} vessel tracks to {} (v2 only)", rowsInserted, tableName);
         }
     }
     
diff --git a/src/main/java/gc/mda/signal_batch/domain/debug/DebugTimeController.java b/src/main/java/gc/mda/signal_batch/domain/debug/DebugTimeController.java
index 09fa041..21990b4 100644
--- a/src/main/java/gc/mda/signal_batch/domain/debug/DebugTimeController.java
+++ b/src/main/java/gc/mda/signal_batch/domain/debug/DebugTimeController.java
@@ -1,5 +1,8 @@
 package gc.mda.signal_batch.domain.debug;
 
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.jdbc.core.JdbcTemplate;
@@ -17,6 +20,7 @@ import java.util.*;
 @Slf4j
 @RestController
 @RequestMapping("/api/debug")
+@Tag(name = "시간 분석 디버그 API", description = "항적 데이터의 시간 정보 및 Unix timestamp 분석 API")
 public class DebugTimeController {
 
     private final DataSource queryDataSource;
@@ -26,11 +30,12 @@ public class DebugTimeController {
     }
     
     @GetMapping("/time-analysis")
+    @Operation(summary = "시간 데이터 분석", description = "특정 선박의 항적 데이터에서 시간 정보(time_bucket, Unix timestamp)를 상세 분석합니다. DB 서버 시간, 최근 데이터, 시간 차이 분석을 포함합니다")
     public Map<String, Object> analyzeTimeData(
-            @RequestParam(defaultValue = "000001") String sigSrcCd,
-            @RequestParam(defaultValue = "440331240") String targetId,
-            @RequestParam(defaultValue = "2025-08-26T08:02:59") String startTime,
-            @RequestParam(defaultValue = "2025-08-27T08:02:59") String endTime) {
+            @Parameter(description = "신호 소스 코드 (기본: 000001)") @RequestParam(defaultValue = "000001") String sigSrcCd,
+            @Parameter(description = "선박 ID (기본: 440331240)") @RequestParam(defaultValue = "440331240") String targetId,
+            @Parameter(description = "시작 시간 (형식: yyyy-MM-ddTHH:mm:ss)") @RequestParam(defaultValue = "2025-08-26T08:02:59") String startTime,
+            @Parameter(description = "종료 시간 (형식: yyyy-MM-ddTHH:mm:ss)") @RequestParam(defaultValue = "2025-08-27T08:02:59") String endTime) {
         
         JdbcTemplate jdbcTemplate = new JdbcTemplate(queryDataSource);
         Map<String, Object> result = new HashMap<>();
diff --git a/src/main/java/gc/mda/signal_batch/domain/gis/controller/GisController.java b/src/main/java/gc/mda/signal_batch/domain/gis/controller/GisController.java
index 83a0af4..bcd73b5 100644
--- a/src/main/java/gc/mda/signal_batch/domain/gis/controller/GisController.java
+++ b/src/main/java/gc/mda/signal_batch/domain/gis/controller/GisController.java
@@ -23,7 +23,7 @@ import java.util.Map;
 @RestController
 @RequestMapping("/api/v1")
 @RequiredArgsConstructor
-@Tag(name = "항적 조회 API", description = "해구 및 영역별 선박 항적 조회 및 통계 API")
+@Tag(name = "항적 조회 API V1", description = "해구 및 영역별 선박 항적 조회 및 통계 API (WKT 응답)")
 public class GisController {
     
     private final GisService gisService;
diff --git a/src/main/java/gc/mda/signal_batch/domain/gis/controller/GisControllerV2.java b/src/main/java/gc/mda/signal_batch/domain/gis/controller/GisControllerV2.java
new file mode 100644
index 0000000..81294d2
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/domain/gis/controller/GisControllerV2.java
@@ -0,0 +1,207 @@
+package gc.mda.signal_batch.domain.gis.controller;
+
+import gc.mda.signal_batch.domain.gis.dto.GisBoundaryResponse;
+import gc.mda.signal_batch.domain.vessel.dto.CompactVesselTrack;
+import gc.mda.signal_batch.domain.vessel.dto.VesselStatsResponse;
+import gc.mda.signal_batch.domain.vessel.dto.VesselTracksRequest;
+import gc.mda.signal_batch.domain.vessel.dto.RecentVesselPositionDto;
+import gc.mda.signal_batch.domain.gis.service.GisService;
+import gc.mda.signal_batch.domain.gis.service.GisServiceV2;
+import gc.mda.signal_batch.domain.vessel.service.VesselPositionService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.ArraySchema;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * GIS API V2 - WebSocket과 동일한 응답 구조 (CompactVesselTrack)
+ *
+ * V1과의 차이점:
+ * - 항적 조회 시 CompactVesselTrack 반환 (선박별 병합, 배열 기반)
+ * - 통합선박 필터링 옵션 지원
+ * - 선박 메타정보(shipName, shipType, nationalCode) 포함
+ */
+@Slf4j
+@RestController
+@RequestMapping("/api/v2")
+@RequiredArgsConstructor
+@Tag(name = "항적 조회 API V2", description = "해구/영역별 선박 항적 조회 API (WebSocket 호환 CompactVesselTrack 응답)")
+public class GisControllerV2 {
+
+    private final GisService gisService;
+    private final GisServiceV2 gisServiceV2;
+    private final VesselPositionService vesselPositionService;
+
+    @GetMapping("/haegu/boundaries")
+    @Operation(
+        summary = "해구 경계 조회",
+        description = "모든 해구의 경계 정보를 GeoJSON 형식으로 반환합니다."
+    )
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200", description = "조회 성공",
+            content = @Content(array = @ArraySchema(schema = @Schema(implementation = GisBoundaryResponse.class))))
+    })
+    public List<GisBoundaryResponse> getHaeguBoundaries() {
+        return gisService.getHaeguBoundaries();
+    }
+
+    @GetMapping("/haegu/vessel-stats")
+    @Operation(
+        summary = "해구별 선박 통계",
+        description = "지정된 시간 범위 내의 해구별 선박 통계를 조회합니다."
+    )
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200", description = "조회 성공")
+    })
+    public Map<Integer, VesselStatsResponse> getHaeguVesselStats(
+            @Parameter(description = "조회 시간 범위 (분)", example = "60")
+            @RequestParam(defaultValue = "60") int minutes) {
+        return gisService.getHaeguVesselStats(minutes);
+    }
+
+    @GetMapping("/areas/boundaries")
+    @Operation(
+        summary = "사용자 정의 영역 경계 조회",
+        description = "모든 사용자 정의 영역의 경계 정보를 GeoJSON 형식으로 반환합니다."
+    )
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200", description = "조회 성공",
+            content = @Content(array = @ArraySchema(schema = @Schema(implementation = GisBoundaryResponse.class))))
+    })
+    public List<GisBoundaryResponse> getAreaBoundaries() {
+        return gisService.getAreaBoundaries();
+    }
+
+    @GetMapping("/areas/vessel-stats")
+    @Operation(
+        summary = "영역별 선박 통계",
+        description = "지정된 시간 범위 내의 영역별 선박 통계를 조회합니다."
+    )
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200", description = "조회 성공")
+    })
+    public Map<String, VesselStatsResponse> getAreaVesselStats(
+            @Parameter(description = "조회 시간 범위 (분)", example = "60")
+            @RequestParam(defaultValue = "60") int minutes) {
+        return gisService.getAreaVesselStats(minutes);
+    }
+
+    @GetMapping("/tracks/haegu/{haeguNo}")
+    @Operation(
+        summary = "해구별 선박 항적 조회",
+        description = """
+            특정 해구 내 선박 항적을 CompactVesselTrack 형식으로 반환합니다.
+
+            **V1과의 차이점:**
+            - 선박별로 병합된 단일 객체 반환 (V1은 세그먼트별 분리)
+            - geometry: [[lon, lat], ...] 배열 형태 (V1은 WKT)
+            - timestamps, speeds 배열 포함
+            - 선박 정보(shipName, shipType, nationalCode) 포함
+            - 통합선박 필터링 지원
+            """
+    )
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200", description = "조회 성공",
+            content = @Content(array = @ArraySchema(schema = @Schema(implementation = CompactVesselTrack.class))))
+    })
+    public List<CompactVesselTrack> getHaeguTracks(
+            @Parameter(description = "해구 번호", example = "1", required = true)
+            @PathVariable Integer haeguNo,
+            @Parameter(description = "조회 시간 범위 (분, 최대 1440)", example = "60")
+            @RequestParam(defaultValue = "60") int minutes,
+            @Parameter(description = "통합선박 필터링 (0: 미적용, 1: 적용)", example = "0",
+                schema = @Schema(allowableValues = {"0", "1"}))
+            @RequestParam(defaultValue = "0") String isIntegration) {
+
+        boolean filterByIntegration = "1".equals(isIntegration);
+        return gisServiceV2.getHaeguTracks(haeguNo, minutes, filterByIntegration);
+    }
+
+    @GetMapping("/tracks/area/{areaId}")
+    @Operation(
+        summary = "영역별 선박 항적 조회",
+        description = """
+            특정 영역 내 선박 항적을 CompactVesselTrack 형식으로 반환합니다.
+
+            **V1과의 차이점:**
+            - 선박별로 병합된 단일 객체 반환 (V1은 세그먼트별 분리)
+            - geometry: [[lon, lat], ...] 배열 형태 (V1은 WKT)
+            - timestamps, speeds 배열 포함
+            - 선박 정보(shipName, shipType, nationalCode) 포함
+            - 통합선박 필터링 지원
+            """
+    )
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200", description = "조회 성공",
+            content = @Content(array = @ArraySchema(schema = @Schema(implementation = CompactVesselTrack.class))))
+    })
+    public List<CompactVesselTrack> getAreaTracks(
+            @Parameter(description = "영역 ID", example = "AREA_001", required = true)
+            @PathVariable String areaId,
+            @Parameter(description = "조회 시간 범위 (분, 최대 1440)", example = "60")
+            @RequestParam(defaultValue = "60") int minutes,
+            @Parameter(description = "통합선박 필터링 (0: 미적용, 1: 적용)", example = "0",
+                schema = @Schema(allowableValues = {"0", "1"}))
+            @RequestParam(defaultValue = "0") String isIntegration) {
+
+        boolean filterByIntegration = "1".equals(isIntegration);
+        return gisServiceV2.getAreaTracks(areaId, minutes, filterByIntegration);
+    }
+
+    @PostMapping("/tracks/vessels")
+    @Operation(
+        summary = "선박별 항적 조회",
+        description = """
+            지정된 선박 목록의 항적을 시간 범위 내에서 조회합니다.
+
+            **응답 구조:** CompactVesselTrack (WebSocket과 동일)
+            - 선박별 병합된 단일 객체
+            - geometry/timestamps/speeds 배열 포함
+            - 선박 메타정보 포함
+            """
+    )
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200", description = "조회 성공",
+            content = @Content(array = @ArraySchema(schema = @Schema(implementation = CompactVesselTrack.class))))
+    })
+    public List<CompactVesselTrack> getVesselTracks(
+            @io.swagger.v3.oas.annotations.parameters.RequestBody(
+                description = "선박 항적 조회 요청",
+                required = true,
+                content = @Content(schema = @Schema(implementation = VesselTracksRequest.class))
+            )
+            @RequestBody VesselTracksRequest request) {
+        return gisService.getVesselTracks(request);
+    }
+
+    @GetMapping("/vessels/recent-positions")
+    @Operation(
+        summary = "최근 위치 업데이트된 선박 조회",
+        description = "지정된 시간(분) 이내에 위치가 업데이트된 모든 선박의 최신 위치 정보를 반환합니다."
+    )
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200", description = "조회 성공",
+            content = @Content(array = @ArraySchema(schema = @Schema(implementation = RecentVesselPositionDto.class)))),
+        @ApiResponse(responseCode = "400", description = "잘못된 파라미터 (minutes: 1~1440)")
+    })
+    public List<RecentVesselPositionDto> getRecentVesselPositions(
+            @Parameter(description = "조회 시간 범위 (분, 1~1440)", example = "5")
+            @RequestParam(defaultValue = "5") int minutes) {
+
+        if (minutes <= 0 || minutes > 1440) {
+            throw new IllegalArgumentException("Minutes must be between 1 and 1440");
+        }
+
+        return vesselPositionService.getRecentVesselPositions(minutes);
+    }
+}
diff --git a/src/main/java/gc/mda/signal_batch/domain/gis/dto/GisBoundaryResponse.java b/src/main/java/gc/mda/signal_batch/domain/gis/dto/GisBoundaryResponse.java
index 9d790fd..25d06e4 100644
--- a/src/main/java/gc/mda/signal_batch/domain/gis/dto/GisBoundaryResponse.java
+++ b/src/main/java/gc/mda/signal_batch/domain/gis/dto/GisBoundaryResponse.java
@@ -1,27 +1,39 @@
 package gc.mda.signal_batch.domain.gis.dto;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Builder;
 import lombok.Data;
 
 @Data
 @Builder
+@Schema(description = "해구/영역 경계 정보")
 public class GisBoundaryResponse {
+
     @JsonProperty("haegu_no")
+    @Schema(description = "해구 번호 (해구 조회 시, 1~약 200)", example = "93")
     private Integer haeguNo;
-    
+
     @JsonProperty("area_id")
+    @Schema(description = "영역 ID (영역 조회 시)", example = "AREA_YEOSU_01")
     private String areaId;
-    
+
     @JsonProperty("area_name")
+    @Schema(description = "영역명", example = "여수 연안")
     private String areaName;
-    
+
     @JsonProperty("geom_json")
-    private String geomJson; // GeoJSON 형식의 geometry
-    
+    @Schema(
+        description = "GeoJSON 형식의 geometry (Polygon)",
+        example = "{\"type\":\"Polygon\",\"coordinates\":[[[127.0,34.2],[127.1,34.2],[127.1,34.3],[127.0,34.3],[127.0,34.2]]]}"
+    )
+    private String geomJson;
+
     @JsonProperty("center_lat")
+    @Schema(description = "중심점 위도", example = "34.22")
     private Double centerLat;
-    
+
     @JsonProperty("center_lon")
+    @Schema(description = "중심점 경도", example = "127.05")
     private Double centerLon;
 }
diff --git a/src/main/java/gc/mda/signal_batch/domain/gis/dto/TileAggregationRequest.java b/src/main/java/gc/mda/signal_batch/domain/gis/dto/TileAggregationRequest.java
index 3b51cb2..9a7217d 100644
--- a/src/main/java/gc/mda/signal_batch/domain/gis/dto/TileAggregationRequest.java
+++ b/src/main/java/gc/mda/signal_batch/domain/gis/dto/TileAggregationRequest.java
@@ -1,5 +1,8 @@
 package gc.mda.signal_batch.domain.gis.dto;
 
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import gc.mda.signal_batch.global.config.FlexibleLocalDateTimeDeserializer;
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -11,8 +14,31 @@ import java.time.LocalDateTime;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
+@Schema(description = "타일 집계 조회 요청")
 public class TileAggregationRequest {
+
+    @Schema(
+        description = """
+            조회 시작 시간.
+            지원 형식: ISO 8601 (2026-01-20T00:00:00, 2026-01-20T00:00:00Z),
+            표준 형식 (2026-01-20 00:00:00), 압축 형식 (20260120000000)
+            """,
+        example = "2026-01-20T00:00:00"
+    )
+    @JsonDeserialize(using = FlexibleLocalDateTimeDeserializer.class)
     private LocalDateTime fromDate;
+
+    @Schema(
+        description = """
+            조회 종료 시간.
+            지원 형식: ISO 8601 (2026-01-20T23:59:59, 2026-01-20T23:59:59Z),
+            표준 형식 (2026-01-20 23:59:59), 압축 형식 (20260120235959)
+            """,
+        example = "2026-01-20T23:59:59"
+    )
+    @JsonDeserialize(using = FlexibleLocalDateTimeDeserializer.class)
     private LocalDateTime toDate;
+
+    @Schema(description = "타일 ID", example = "12_3456_7890")
     private String tileId;
 }
diff --git a/src/main/java/gc/mda/signal_batch/domain/gis/service/GisService.java b/src/main/java/gc/mda/signal_batch/domain/gis/service/GisService.java
index 8e4e963..37c79f7 100644
--- a/src/main/java/gc/mda/signal_batch/domain/gis/service/GisService.java
+++ b/src/main/java/gc/mda/signal_batch/domain/gis/service/GisService.java
@@ -8,6 +8,8 @@ import gc.mda.signal_batch.domain.vessel.dto.CompactVesselTrack;
 import gc.mda.signal_batch.domain.vessel.dto.IntegrationVessel;
 import gc.mda.signal_batch.domain.vessel.service.IntegrationVesselService;
 import gc.mda.signal_batch.global.util.IntegrationSignalConstants;
+import gc.mda.signal_batch.global.util.NationalCodeUtil;
+import gc.mda.signal_batch.global.util.ShipKindCodeConverter;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.jdbc.core.JdbcTemplate;
@@ -568,11 +570,22 @@ public class GisService {
         
         // Get vessel info
         Map<String, String> vesselInfo = getVesselInfo(vessel.getSigSrcCd(), vessel.getTargetId());
-        
+        String shipName = vesselInfo.get("ship_name");
+        String shipType = vesselInfo.get("ship_type");
+
+        // Calculate nationalCode (same as WebSocket)
+        String nationalCode = NationalCodeUtil.calculateNationalCode(
+                vessel.getSigSrcCd(), vessel.getTargetId());
+
+        // Calculate shipKindCode (same as WebSocket - using name pattern matching for buoy/net detection)
+        String shipKindCode = ShipKindCodeConverter.getShipKindCodeWithNamePattern(
+                vessel.getSigSrcCd(), shipType, shipName, vessel.getTargetId());
+
         return CompactVesselTrack.builder()
             .vesselId(vesselId)
             .sigSrcCd(vessel.getSigSrcCd())
             .targetId(vessel.getTargetId())
+            .nationalCode(nationalCode)
             .geometry(geometry)
             .timestamps(timestamps)
             .speeds(speeds)
@@ -580,9 +593,9 @@ public class GisService {
             .avgSpeed(avgSpeed)
             .maxSpeed(maxSpeed)
             .pointCount(geometry.size())
-            .shipName(vesselInfo.get("ship_name"))
-            .shipType(vesselInfo.get("ship_type"))
-            .shipKindCode(null) // Not available in current schema
+            .shipName(shipName)
+            .shipType(shipType)
+            .shipKindCode(shipKindCode)
             .build();
     }
     
diff --git a/src/main/java/gc/mda/signal_batch/domain/gis/service/GisServiceV2.java b/src/main/java/gc/mda/signal_batch/domain/gis/service/GisServiceV2.java
new file mode 100644
index 0000000..f80dbb7
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/domain/gis/service/GisServiceV2.java
@@ -0,0 +1,370 @@
+package gc.mda.signal_batch.domain.gis.service;
+
+import gc.mda.signal_batch.domain.vessel.dto.CompactVesselTrack;
+import gc.mda.signal_batch.domain.vessel.dto.TrackResponse;
+import gc.mda.signal_batch.domain.vessel.dto.IntegrationVessel;
+import gc.mda.signal_batch.domain.vessel.service.IntegrationVesselService;
+import gc.mda.signal_batch.global.util.IntegrationSignalConstants;
+import gc.mda.signal_batch.global.util.TrackConverter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+
+import javax.sql.DataSource;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+/**
+ * GIS 서비스 V2 - CompactVesselTrack 기반 응답
+ * WebSocket API와 동일한 응답 구조 제공
+ */
+@Slf4j
+@Service
+public class GisServiceV2 {
+
+    private final DataSource queryDataSource;
+    private final IntegrationVesselService integrationVesselService;
+
+    // 선박 정보 캐시 (TTL: 1시간)
+    private final ConcurrentHashMap<String, VesselInfoCache> vesselInfoCache = new ConcurrentHashMap<>();
+    private static final long VESSEL_CACHE_TTL = 3600_000; // 1시간
+
+    public GisServiceV2(@Qualifier("queryDataSource") DataSource queryDataSource,
+                        IntegrationVesselService integrationVesselService) {
+        this.queryDataSource = queryDataSource;
+        this.integrationVesselService = integrationVesselService;
+    }
+
+    /**
+     * 해구별 선박 항적 조회 (V2 - CompactVesselTrack 반환)
+     */
+    public List<CompactVesselTrack> getHaeguTracks(Integer haeguNo, int minutes, boolean filterByIntegration) {
+        JdbcTemplate jdbcTemplate = new JdbcTemplate(queryDataSource);
+        List<TrackResponse> rawTracks = new ArrayList<>();
+
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime startTime = now.minusMinutes(minutes);
+
+        if (minutes > 60) {
+            LocalDateTime currentHour = now.withMinute(0).withSecond(0).withNano(0);
+
+            if (minutes <= 1440) {
+                // hourly 테이블에서 과거 데이터 조회
+                String hourlySql = """
+                    SELECT DISTINCT t.sig_src_cd, t.target_id, t.time_bucket,
+                           public.ST_AsText(t.track_geom) as track_geom,
+                           t.distance_nm, t.avg_speed, t.max_speed, t.point_count
+                    FROM signal.t_vessel_tracks_hourly t
+                    WHERE EXISTS (
+                        SELECT 1 FROM signal.t_grid_vessel_tracks g
+                        WHERE g.sig_src_cd = t.sig_src_cd
+                            AND g.target_id = t.target_id
+                            AND g.haegu_no = %d
+                            AND g.time_bucket >= '%s'
+                    )
+                    AND t.time_bucket >= '%s'
+                    AND t.time_bucket < '%s'
+                    ORDER BY t.sig_src_cd, t.target_id, t.time_bucket
+                """.formatted(haeguNo, startTime, startTime, currentHour);
+
+                rawTracks.addAll(jdbcTemplate.query(hourlySql, this::mapTrackResponse));
+            }
+
+            // 5min 테이블에서 최근 데이터 조회
+            String recentSql = """
+                SELECT DISTINCT t.sig_src_cd, t.target_id, t.time_bucket,
+                       public.ST_AsText(t.track_geom) as track_geom,
+                       t.distance_nm, t.avg_speed, t.max_speed, t.point_count
+                FROM signal.t_vessel_tracks_5min t
+                WHERE EXISTS (
+                    SELECT 1 FROM signal.t_grid_vessel_tracks g
+                    WHERE g.sig_src_cd = t.sig_src_cd
+                        AND g.target_id = t.target_id
+                        AND g.haegu_no = %d
+                        AND g.time_bucket >= '%s'
+                )
+                AND t.time_bucket >= '%s'
+                ORDER BY t.sig_src_cd, t.target_id, t.time_bucket
+            """.formatted(haeguNo, startTime, currentHour);
+
+            rawTracks.addAll(jdbcTemplate.query(recentSql, this::mapTrackResponse));
+
+        } else {
+            // 1시간 이하는 5분 테이블만 사용
+            String sql = """
+                SELECT DISTINCT t.sig_src_cd, t.target_id, t.time_bucket,
+                       public.ST_AsText(t.track_geom) as track_geom,
+                       t.distance_nm, t.avg_speed, t.max_speed, t.point_count
+                FROM signal.t_vessel_tracks_5min t
+                WHERE EXISTS (
+                    SELECT 1 FROM signal.t_grid_vessel_tracks g
+                    WHERE g.sig_src_cd = t.sig_src_cd
+                        AND g.target_id = t.target_id
+                        AND g.haegu_no = %d
+                        AND g.time_bucket >= NOW() - INTERVAL '%d minutes'
+                )
+                AND t.time_bucket >= NOW() - INTERVAL '%d minutes'
+                ORDER BY t.sig_src_cd, t.target_id, t.time_bucket
+            """.formatted(haeguNo, minutes, minutes);
+
+            rawTracks = jdbcTemplate.query(sql, this::mapTrackResponse);
+        }
+
+        // CompactVesselTrack으로 변환
+        List<CompactVesselTrack> result = TrackConverter.convert(rawTracks, this::getVesselInfo);
+
+        // 통합선박 필터링 적용
+        if (filterByIntegration && integrationVesselService.isEnabled()) {
+            result = filterByIntegration(result);
+        }
+
+        log.debug("V2 API: Fetched {} compact tracks for haegu {} in last {} minutes",
+                result.size(), haeguNo, minutes);
+
+        return result;
+    }
+
+    /**
+     * 영역별 선박 항적 조회 (V2 - CompactVesselTrack 반환)
+     */
+    public List<CompactVesselTrack> getAreaTracks(String areaId, int minutes, boolean filterByIntegration) {
+        JdbcTemplate jdbcTemplate = new JdbcTemplate(queryDataSource);
+        List<TrackResponse> rawTracks = new ArrayList<>();
+
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime startTime = now.minusMinutes(minutes);
+
+        if (minutes > 60) {
+            LocalDateTime currentHour = now.withMinute(0).withSecond(0).withNano(0);
+
+            if (minutes <= 1440) {
+                // hourly 테이블에서 과거 데이터 조회
+                String hourlySql = """
+                    SELECT DISTINCT t.sig_src_cd, t.target_id, t.time_bucket,
+                           public.ST_AsText(t.track_geom) as track_geom,
+                           t.distance_nm, t.avg_speed, t.max_speed, t.point_count
+                    FROM signal.t_vessel_tracks_hourly t
+                    WHERE EXISTS (
+                        SELECT 1 FROM signal.t_area_vessel_tracks a
+                        WHERE a.sig_src_cd = t.sig_src_cd
+                            AND a.target_id = t.target_id
+                            AND a.area_id = '%s'
+                            AND a.time_bucket >= '%s'
+                    )
+                    AND t.time_bucket >= '%s'
+                    AND t.time_bucket < '%s'
+                    ORDER BY t.sig_src_cd, t.target_id, t.time_bucket
+                """.formatted(areaId, startTime, startTime, currentHour);
+
+                rawTracks.addAll(jdbcTemplate.query(hourlySql, this::mapTrackResponse));
+            }
+
+            // 5min 테이블에서 최근 데이터 조회
+            String recentSql = """
+                SELECT DISTINCT t.sig_src_cd, t.target_id, t.time_bucket,
+                       public.ST_AsText(t.track_geom) as track_geom,
+                       t.distance_nm, t.avg_speed, t.max_speed, t.point_count
+                FROM signal.t_vessel_tracks_5min t
+                WHERE EXISTS (
+                    SELECT 1 FROM signal.t_area_vessel_tracks a
+                    WHERE a.sig_src_cd = t.sig_src_cd
+                        AND a.target_id = t.target_id
+                        AND a.area_id = '%s'
+                        AND a.time_bucket >= '%s'
+                )
+                AND t.time_bucket >= '%s'
+                ORDER BY t.sig_src_cd, t.target_id, t.time_bucket
+            """.formatted(areaId, startTime, currentHour);
+
+            rawTracks.addAll(jdbcTemplate.query(recentSql, this::mapTrackResponse));
+
+        } else {
+            // 1시간 이하는 5분 테이블만 사용
+            String sql = """
+                SELECT DISTINCT t.sig_src_cd, t.target_id, t.time_bucket,
+                       public.ST_AsText(t.track_geom) as track_geom,
+                       t.distance_nm, t.avg_speed, t.max_speed, t.point_count
+                FROM signal.t_vessel_tracks_5min t
+                WHERE EXISTS (
+                    SELECT 1 FROM signal.t_area_vessel_tracks a
+                    WHERE a.sig_src_cd = t.sig_src_cd
+                        AND a.target_id = t.target_id
+                        AND a.area_id = '%s'
+                        AND a.time_bucket >= NOW() - INTERVAL '%d minutes'
+                )
+                AND t.time_bucket >= NOW() - INTERVAL '%d minutes'
+                ORDER BY t.sig_src_cd, t.target_id, t.time_bucket
+            """.formatted(areaId, minutes, minutes);
+
+            rawTracks = jdbcTemplate.query(sql, this::mapTrackResponse);
+        }
+
+        // CompactVesselTrack으로 변환
+        List<CompactVesselTrack> result = TrackConverter.convert(rawTracks, this::getVesselInfo);
+
+        // 통합선박 필터링 적용
+        if (filterByIntegration && integrationVesselService.isEnabled()) {
+            result = filterByIntegration(result);
+        }
+
+        log.debug("V2 API: Fetched {} compact tracks for area {} in last {} minutes",
+                result.size(), areaId, minutes);
+
+        return result;
+    }
+
+    /**
+     * TrackResponse 매핑
+     */
+    private TrackResponse mapTrackResponse(ResultSet rs, int rowNum) throws SQLException {
+        return TrackResponse.builder()
+                .sigSrcCd(rs.getString("sig_src_cd"))
+                .targetId(rs.getString("target_id"))
+                .timeBucket(rs.getObject("time_bucket", LocalDateTime.class))
+                .trackGeom(rs.getString("track_geom"))
+                .distanceNm(rs.getBigDecimal("distance_nm"))
+                .avgSpeed(rs.getBigDecimal("avg_speed"))
+                .maxSpeed(rs.getBigDecimal("max_speed"))
+                .pointCount(rs.getInt("point_count"))
+                .build();
+    }
+
+    /**
+     * 선박 정보 조회 (캐시 우선)
+     */
+    private TrackConverter.VesselInfo getVesselInfo(String sigSrcCd, String targetId) {
+        String cacheKey = sigSrcCd + "_" + targetId;
+
+        VesselInfoCache cached = vesselInfoCache.get(cacheKey);
+        if (cached != null && !cached.isExpired()) {
+            return new TrackConverter.VesselInfo(cached.shipName, cached.shipType);
+        }
+
+        // DB 조회
+        JdbcTemplate jdbcTemplate = new JdbcTemplate(queryDataSource);
+        try {
+            String sql = """
+                SELECT ship_nm, ship_ty
+                FROM signal.t_vessel_latest_position
+                WHERE sig_src_cd = ? AND target_id = ?
+                LIMIT 1
+            """;
+
+            Map<String, Object> result = jdbcTemplate.queryForMap(sql, sigSrcCd, targetId);
+            String shipName = result.get("ship_nm") != null ? result.get("ship_nm").toString() : "-";
+            String shipType = result.get("ship_ty") != null ? result.get("ship_ty").toString() : "-";
+
+            // 캐시 저장
+            vesselInfoCache.put(cacheKey, new VesselInfoCache(shipName, shipType));
+
+            return new TrackConverter.VesselInfo(shipName, shipType);
+        } catch (Exception e) {
+            return new TrackConverter.VesselInfo("-", "-");
+        }
+    }
+
+    /**
+     * 통합선박 기준 필터링
+     */
+    private List<CompactVesselTrack> filterByIntegration(List<CompactVesselTrack> tracks) {
+        if (tracks == null || tracks.isEmpty()) {
+            return tracks;
+        }
+
+        // 1. 모든 트랙의 통합선박 정보 조회
+        Map<String, IntegrationVessel> vesselIntegrations = new HashMap<>();
+        for (CompactVesselTrack track : tracks) {
+            String key = track.getSigSrcCd() + "_" + track.getTargetId();
+            if (!vesselIntegrations.containsKey(key)) {
+                IntegrationVessel integration = integrationVesselService.findByVessel(
+                        track.getSigSrcCd(), track.getTargetId()
+                );
+                vesselIntegrations.put(key, integration);
+            }
+        }
+
+        // 2. 통합선박별 그룹핑
+        Map<Long, List<CompactVesselTrack>> groupedByIntegration = new HashMap<>();
+        Map<Long, IntegrationVessel> integrationMap = new HashMap<>();
+
+        long tempSeq = -1;
+        for (CompactVesselTrack track : tracks) {
+            String key = track.getSigSrcCd() + "_" + track.getTargetId();
+            IntegrationVessel integration = vesselIntegrations.get(key);
+
+            Long seq;
+            if (integration != null) {
+                seq = integration.getIntgrSeq();
+                integrationMap.putIfAbsent(seq, integration);
+            } else {
+                seq = tempSeq--;
+            }
+
+            groupedByIntegration.computeIfAbsent(seq, k -> new ArrayList<>()).add(track);
+        }
+
+        // 3. 각 그룹에서 최고 우선순위 신호만 선택
+        List<CompactVesselTrack> result = new ArrayList<>();
+
+        for (Map.Entry<Long, List<CompactVesselTrack>> entry : groupedByIntegration.entrySet()) {
+            Long seq = entry.getKey();
+            List<CompactVesselTrack> groupTracks = entry.getValue();
+
+            if (seq < 0) {
+                // 통합정보 없는 단독 선박
+                CompactVesselTrack firstTrack = groupTracks.get(0);
+                String soloIntegrationId = IntegrationSignalConstants.generateSoloIntegrationId(
+                        firstTrack.getSigSrcCd(),
+                        firstTrack.getTargetId()
+                );
+                groupTracks.forEach(t -> t.setIntegrationTargetId(soloIntegrationId));
+                result.addAll(groupTracks);
+            } else {
+                // 통합선박 → 존재하는 신호 중 최고 우선순위 선택
+                IntegrationVessel integration = integrationMap.get(seq);
+
+                Set<String> existingSigSrcCds = groupTracks.stream()
+                        .map(CompactVesselTrack::getSigSrcCd)
+                        .collect(Collectors.toSet());
+
+                String selectedSigSrcCd = integrationVesselService.selectHighestPriorityFromExisting(existingSigSrcCds);
+
+                List<CompactVesselTrack> selectedTracks = groupTracks.stream()
+                        .filter(t -> t.getSigSrcCd().equals(selectedSigSrcCd))
+                        .collect(Collectors.toList());
+
+                String integrationId = integration.generateIntegrationId();
+                selectedTracks.forEach(t -> t.setIntegrationTargetId(integrationId));
+
+                result.addAll(selectedTracks);
+            }
+        }
+
+        log.info("[INTEGRATION_FILTER] V2 API - Filtered {} tracks to {} tracks", tracks.size(), result.size());
+        return result;
+    }
+
+    /**
+     * 선박 정보 캐시 내부 클래스
+     */
+    private static class VesselInfoCache {
+        String shipName;
+        String shipType;
+        long cacheTime;
+
+        VesselInfoCache(String shipName, String shipType) {
+            this.shipName = shipName;
+            this.shipType = shipType;
+            this.cacheTime = System.currentTimeMillis();
+        }
+
+        boolean isExpired() {
+            return System.currentTimeMillis() - cacheTime > VESSEL_CACHE_TTL;
+        }
+    }
+}
diff --git a/src/main/java/gc/mda/signal_batch/domain/passage/dto/SequentialPassageRequest.java b/src/main/java/gc/mda/signal_batch/domain/passage/dto/SequentialPassageRequest.java
index 19172d9..f250a14 100644
--- a/src/main/java/gc/mda/signal_batch/domain/passage/dto/SequentialPassageRequest.java
+++ b/src/main/java/gc/mda/signal_batch/domain/passage/dto/SequentialPassageRequest.java
@@ -1,5 +1,7 @@
 package gc.mda.signal_batch.domain.passage.dto;
 
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import gc.mda.signal_batch.global.config.FlexibleLocalDateTimeDeserializer;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -17,13 +19,31 @@ import java.util.List;
 @AllArgsConstructor
 @Schema(description = "순차 구역 통과 조회 요청")
 public class SequentialPassageRequest {
-    
+
     @NotNull(message = "조회 시작 시간은 필수입니다")
-    @Schema(description = "조회 시작 시간", example = "2025-08-01T00:00:00", required = true)
+    @Schema(
+        description = """
+            조회 시작 시간.
+            지원 형식: ISO 8601 (2025-08-01T00:00:00, 2025-08-01T00:00:00Z),
+            표준 형식 (2025-08-01 00:00:00), 압축 형식 (20250801000000)
+            """,
+        example = "2025-08-01T00:00:00",
+        required = true
+    )
+    @JsonDeserialize(using = FlexibleLocalDateTimeDeserializer.class)
     private LocalDateTime startTime;
-    
+
     @NotNull(message = "조회 종료 시간은 필수입니다")
-    @Schema(description = "조회 종료 시간", example = "2025-08-07T23:59:59", required = true)
+    @Schema(
+        description = """
+            조회 종료 시간.
+            지원 형식: ISO 8601 (2025-08-07T23:59:59, 2025-08-07T23:59:59Z),
+            표준 형식 (2025-08-07 23:59:59), 압축 형식 (20250807235959)
+            """,
+        example = "2025-08-07T23:59:59",
+        required = true
+    )
+    @JsonDeserialize(using = FlexibleLocalDateTimeDeserializer.class)
     private LocalDateTime endTime;
     
     @Schema(description = "조회 유형 (GRID: 해구, AREA: 사용자정의구역)", example = "GRID", required = true)
diff --git a/src/main/java/gc/mda/signal_batch/domain/passage/service/SequentialAreaTrackingService.java b/src/main/java/gc/mda/signal_batch/domain/passage/service/SequentialAreaTrackingService.java
index 925dcd9..5fc9f3e 100644
--- a/src/main/java/gc/mda/signal_batch/domain/passage/service/SequentialAreaTrackingService.java
+++ b/src/main/java/gc/mda/signal_batch/domain/passage/service/SequentialAreaTrackingService.java
@@ -44,11 +44,11 @@ public class SequentialAreaTrackingService {
                     sig_src_cd,
                     target_id,
                     haegu_no,
-                    FIRpublic.ST_VALUE(time_bucket) OVER (
+                    FIRST_VALUE(time_bucket) OVER (
                         PARTITION BY sig_src_cd, target_id, haegu_no 
                         ORDER BY time_bucket
                     ) as entry_time,
-                    LApublic.ST_VALUE(time_bucket) OVER (
+                    LAST_VALUE(time_bucket) OVER (
                         PARTITION BY sig_src_cd, target_id, haegu_no 
                         ORDER BY time_bucket 
                         ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
@@ -103,11 +103,11 @@ public class SequentialAreaTrackingService {
                     sig_src_cd,
                     target_id,
                     area_id,
-                    FIRpublic.ST_VALUE(time_bucket) OVER (
+                    FIRST_VALUE(time_bucket) OVER (
                         PARTITION BY sig_src_cd, target_id, area_id 
                         ORDER BY time_bucket
                     ) as entry_time,
-                    LApublic.ST_VALUE(time_bucket) OVER (
+                    LAST_VALUE(time_bucket) OVER (
                         PARTITION BY sig_src_cd, target_id, area_id 
                         ORDER BY time_bucket 
                         ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
diff --git a/src/main/java/gc/mda/signal_batch/domain/ship/controller/ShipImageController.java b/src/main/java/gc/mda/signal_batch/domain/ship/controller/ShipImageController.java
new file mode 100644
index 0000000..39a15e9
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/domain/ship/controller/ShipImageController.java
@@ -0,0 +1,56 @@
+package gc.mda.signal_batch.domain.ship.controller;
+
+import gc.mda.signal_batch.domain.ship.dto.ShipImageDto;
+import gc.mda.signal_batch.domain.ship.service.ShipImageService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.ArraySchema;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@Slf4j
+@RestController
+@RequestMapping("/api/v1/shipimg")
+@RequiredArgsConstructor
+@Tag(name = "Ship Image", description = "선박 이미지 API")
+public class ShipImageController {
+
+    private final ShipImageService shipImageService;
+
+    @GetMapping("/{imo}")
+    @Operation(
+            summary = "선박 이미지 경로 조회",
+            description = "IMO 번호로 선박 이미지 경로 목록을 조회합니다. 프론트엔드에서 썸네일은 path + '_1.jpg', 원본은 path + '_2.jpg'를 사용합니다."
+    )
+    @ApiResponses(value = {
+            @ApiResponse(
+                    responseCode = "200",
+                    description = "조회 성공 (데이터 없으면 빈 배열 반환)",
+                    content = @Content(array = @ArraySchema(schema = @Schema(implementation = ShipImageDto.class)))
+            )
+    })
+    public ResponseEntity<List<ShipImageDto>> getShipImages(
+            @Parameter(description = "IMO 번호", example = "9141833")
+            @PathVariable Integer imo) {
+
+        log.debug("Requesting ship images for IMO: {}", imo);
+
+        List<ShipImageDto> images = shipImageService.getImagesByImo(imo);
+
+        log.debug("Found {} images for IMO: {}", images.size(), imo);
+
+        return ResponseEntity.ok(images);
+    }
+}
diff --git a/src/main/java/gc/mda/signal_batch/domain/ship/dto/ShipImageDto.java b/src/main/java/gc/mda/signal_batch/domain/ship/dto/ShipImageDto.java
new file mode 100644
index 0000000..db77554
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/domain/ship/dto/ShipImageDto.java
@@ -0,0 +1,18 @@
+package gc.mda.signal_batch.domain.ship.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.LocalDate;
+
+@Data
+@Builder
+public class ShipImageDto {
+    private Integer picId;
+    private String path;
+    private String copyright;
+
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private LocalDate date;
+}
diff --git a/src/main/java/gc/mda/signal_batch/domain/ship/repository/ShipImageRepository.java b/src/main/java/gc/mda/signal_batch/domain/ship/repository/ShipImageRepository.java
new file mode 100644
index 0000000..a97989f
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/domain/ship/repository/ShipImageRepository.java
@@ -0,0 +1,58 @@
+package gc.mda.signal_batch.domain.ship.repository;
+
+import gc.mda.signal_batch.domain.ship.dto.ShipImageDto;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.stereotype.Repository;
+
+import java.sql.Date;
+import java.util.List;
+
+@Slf4j
+@Repository
+public class ShipImageRepository {
+
+    private final JdbcTemplate queryJdbcTemplate;
+
+    public ShipImageRepository(@Qualifier("queryJdbcTemplate") JdbcTemplate queryJdbcTemplate) {
+        this.queryJdbcTemplate = queryJdbcTemplate;
+    }
+
+    private static final String FIND_BY_IMO_SQL = """
+        SELECT pic_id, copyright, dateofphoto
+        FROM signal.t_snp_ship_img
+        WHERE lrno = ?
+        ORDER BY dateofphoto DESC NULLS LAST, pic_id DESC
+        """;
+
+    private static final RowMapper<ShipImageRawData> ROW_MAPPER = (rs, rowNum) -> {
+        ShipImageRawData data = new ShipImageRawData();
+        data.picId = rs.getInt("pic_id");
+        data.copyright = rs.getString("copyright");
+        Date dateOfPhoto = rs.getDate("dateofphoto");
+        data.dateOfPhoto = dateOfPhoto != null ? dateOfPhoto.toLocalDate() : null;
+        return data;
+    };
+
+    /**
+     * IMO(lrno)로 이미지 정보 조회
+     *
+     * @param imo IMO 번호
+     * @return 이미지 raw 데이터 목록
+     */
+    public List<ShipImageRawData> findByImo(Integer imo) {
+        return queryJdbcTemplate.query(FIND_BY_IMO_SQL, ROW_MAPPER, imo);
+    }
+
+    /**
+     * Repository 내부에서 사용하는 Raw 데이터 클래스
+     */
+    public static class ShipImageRawData {
+        public Integer picId;
+        public String copyright;
+        public java.time.LocalDate dateOfPhoto;
+    }
+}
diff --git a/src/main/java/gc/mda/signal_batch/domain/ship/service/ShipImageService.java b/src/main/java/gc/mda/signal_batch/domain/ship/service/ShipImageService.java
new file mode 100644
index 0000000..eb80200
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/domain/ship/service/ShipImageService.java
@@ -0,0 +1,58 @@
+package gc.mda.signal_batch.domain.ship.service;
+
+import gc.mda.signal_batch.domain.ship.dto.ShipImageDto;
+import gc.mda.signal_batch.domain.ship.repository.ShipImageRepository;
+import gc.mda.signal_batch.domain.ship.repository.ShipImageRepository.ShipImageRawData;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class ShipImageService {
+
+    private final ShipImageRepository shipImageRepository;
+
+    /**
+     * IMO로 이미지 정보 목록 조회
+     *
+     * @param imo IMO 번호
+     * @return 이미지 정보 목록 (없으면 빈 배열)
+     */
+    public List<ShipImageDto> getImagesByImo(Integer imo) {
+        List<ShipImageRawData> rawDataList = shipImageRepository.findByImo(imo);
+
+        return rawDataList.stream()
+                .map(this::toDto)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Raw 데이터를 DTO로 변환
+     */
+    private ShipImageDto toDto(ShipImageRawData rawData) {
+        return ShipImageDto.builder()
+                .picId(rawData.picId)
+                .path(buildImagePath(rawData.picId))
+                .copyright(rawData.copyright)
+                .date(rawData.dateOfPhoto)
+                .build();
+    }
+
+    /**
+     * pic_id로 이미지 경로 생성
+     * 규칙: 폴더명 = pic_id / 100
+     * 예: pic_id=816100 → /shipimg/8161/816100
+     *
+     * @param picId pic_id
+     * @return 이미지 경로
+     */
+    private String buildImagePath(Integer picId) {
+        int folderName = picId / 100;
+        return String.format("/shipimg/%d/%d", folderName, picId);
+    }
+}
diff --git a/src/main/java/gc/mda/signal_batch/domain/track/controller/AbnormalTrackController.java b/src/main/java/gc/mda/signal_batch/domain/track/controller/AbnormalTrackController.java
index 45b278b..12cfc72 100644
--- a/src/main/java/gc/mda/signal_batch/domain/track/controller/AbnormalTrackController.java
+++ b/src/main/java/gc/mda/signal_batch/domain/track/controller/AbnormalTrackController.java
@@ -1,10 +1,13 @@
 package gc.mda.signal_batch.domain.track.controller;
 
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import gc.mda.signal_batch.domain.track.dto.AbnormalTrackResponse;
 import gc.mda.signal_batch.domain.track.dto.AbnormalTrackStatsResponse;
 import gc.mda.signal_batch.domain.track.service.AbnormalTrackService;
+import gc.mda.signal_batch.global.config.FlexibleLocalDateTimeDeserializer;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -17,7 +20,6 @@ import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Map;
 import java.math.BigDecimal;
-import com.fasterxml.jackson.annotation.JsonFormat;
 
 
 /**
@@ -135,31 +137,67 @@ public class AbnormalTrackController {
     
     @lombok.Data
     static class DetectRequest {
-        private String tableType; // "hourly" or "daily"
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
+        @Schema(description = "테이블 유형", example = "hourly", allowableValues = {"hourly", "daily"})
+        private String tableType;
+
+        @Schema(
+            description = """
+                조회 시작 시간.
+                지원 형식: ISO 8601, 표준 형식 (YYYY-MM-DD HH:MM:SS), 압축 형식 (YYYYMMDDHHMMSS)
+                """,
+            example = "2026-01-20T00:00:00"
+        )
+        @JsonDeserialize(using = FlexibleLocalDateTimeDeserializer.class)
         private LocalDateTime startTime;
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
+
+        @Schema(
+            description = """
+                조회 종료 시간.
+                지원 형식: ISO 8601, 표준 형식 (YYYY-MM-DD HH:MM:SS), 압축 형식 (YYYYMMDDHHMMSS)
+                """,
+            example = "2026-01-20T23:59:59"
+        )
+        @JsonDeserialize(using = FlexibleLocalDateTimeDeserializer.class)
         private LocalDateTime endTime;
-        private BigDecimal minDistance; // 최소 거리 (nm)
-        private BigDecimal minSpeed; // 최소 평균속도 (knots)
+
+        @Schema(description = "최소 거리 (nm)", example = "10.0")
+        private BigDecimal minDistance;
+
+        @Schema(description = "최소 평균속도 (knots)", example = "50.0")
+        private BigDecimal minSpeed;
     }
-    
+
     @lombok.Data
     static class MoveTracksRequest {
-        private String tableType; // "hourly" or "daily"
+        @Schema(description = "테이블 유형", example = "hourly", allowableValues = {"hourly", "daily"})
+        private String tableType;
+
+        @Schema(description = "이동할 항적 목록")
         private List<TrackIdentifier> tracks;
+
+        @Schema(description = "비정상 유형", example = "SPEED_ANOMALY")
         private String abnormalType;
+
+        @Schema(description = "이동 사유", example = "물리적으로 불가능한 속도")
         private String reason;
     }
-    
+
     @lombok.Data
     public static class TrackIdentifier {
+        @Schema(description = "신호 소스 코드", example = "000001")
         private String sigSrcCd;
+
+        @Schema(description = "타겟 ID", example = "440123456")
         private String targetId;
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
+
+        @Schema(
+            description = """
+                시간 버킷.
+                지원 형식: ISO 8601, 표준 형식 (YYYY-MM-DD HH:MM:SS), 압축 형식 (YYYYMMDDHHMMSS)
+                """,
+            example = "2026-01-20T10:00:00"
+        )
+        @JsonDeserialize(using = FlexibleLocalDateTimeDeserializer.class)
         private LocalDateTime timeBucket;
     }
     
diff --git a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/CompactVesselTrack.java b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/CompactVesselTrack.java
index c598eae..d646ad2 100644
--- a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/CompactVesselTrack.java
+++ b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/CompactVesselTrack.java
@@ -2,12 +2,15 @@ package gc.mda.signal_batch.domain.vessel.dto;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.v3.oas.annotations.media.ArraySchema;
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.util.List;
+
 /**
  * 압축된 선박 궤적 데이터 전송용 DTO
  * LineStringM 대신 단순 배열로 전송하여 프론트엔드 파싱 부하 제거
@@ -17,32 +20,80 @@ import java.util.List;
 @NoArgsConstructor
 @AllArgsConstructor
 @JsonInclude(JsonInclude.Include.NON_NULL)
+@Schema(description = "선박별 병합된 항적 데이터 (WebSocket/REST 공통)")
 public class CompactVesselTrack {
-    private String vesselId;           // sig_src_cd + "_" + target_id
-    private String sigSrcCd;
-    private String targetId;
-    private String nationalCode;       // National code based on sigSrcCd and targetId
-    
-    // 궤적 데이터 (배열 형태)
-    private List<double[]> geometry;   // [[lon, lat], ...]
-    
-    // MIGRATION_V2: 호환성을 위해 모두 String으로 처리
-    @JsonProperty("timestamps")
-    private List<String> timestamps;   // String 리스트 (Unix timestamp도 String으로 변환)
-    
-    private List<Double> speeds;       // [12.5, 13.2, ...]
-    
-    // 메타데이터
-    private Double totalDistance;      // 전체 이동거리 (nm)
-    private Double avgSpeed;           // 평균속도 (knots)
-    private Double maxSpeed;           // 최대속도 (knots)
-    private Integer pointCount;        // 포인트 수
-    
-    // 선박 정보
-    private String shipName;           // 선명
-    private String shipType;           // 선종
-    private String shipKindCode;       // 선박 종류 코드
 
-    // 통합선박 정보
-    private String integrationTargetId; // 통합선박 ID (형식: AIS_ENAV_VPASS_VTS-AIS_D-MF/HF)
+    @Schema(description = "선박 고유 ID (sigSrcCd_targetId)", example = "000001_440113620")
+    private String vesselId;
+
+    @Schema(description = "신호 소스 코드", example = "000001")
+    private String sigSrcCd;
+
+    @Schema(description = "타겟 ID (MMSI 등)", example = "440113620")
+    private String targetId;
+
+    @Schema(description = "국적 코드 (MID 기반, MMSI 앞 3자리로 판별)", example = "KR")
+    private String nationalCode;
+
+    @ArraySchema(
+        schema = @Schema(
+            description = "좌표 [경도, 위도]",
+            type = "array",
+            example = "[127.0638, 34.227527]"
+        ),
+        arraySchema = @Schema(
+            description = "궤적 좌표 배열 [[lon, lat], ...] - 시간순 정렬",
+            example = "[[127.0638, 34.227527], [127.063303, 34.226685], [127.063008, 34.226203]]"
+        )
+    )
+    private List<double[]> geometry;
+
+    @ArraySchema(
+        schema = @Schema(description = "Unix timestamp (초)", example = "1768878312"),
+        arraySchema = @Schema(
+            description = "각 좌표에 대응하는 Unix timestamp 배열",
+            example = "[\"1768878312\", \"1768878332\", \"1768878342\"]"
+        )
+    )
+    @JsonProperty("timestamps")
+    private List<String> timestamps;
+
+    @ArraySchema(
+        schema = @Schema(description = "속도 (knots)", example = "10.4"),
+        arraySchema = @Schema(
+            description = "각 좌표에 대응하는 속도 배열 (knots)",
+            example = "[10.4, 10.4, 10.67]"
+        )
+    )
+    private List<Double> speeds;
+
+    @Schema(description = "전체 이동거리 (해리)", example = "1.64")
+    private Double totalDistance;
+
+    @Schema(description = "평균 속도 (knots)", example = "10.54")
+    private Double avgSpeed;
+
+    @Schema(description = "최대 속도 (knots)", example = "10.9")
+    private Double maxSpeed;
+
+    @Schema(description = "궤적 포인트 수", example = "38")
+    private Integer pointCount;
+
+    @Schema(description = "선박명", example = "SAM SUNG 2HO")
+    private String shipName;
+
+    @Schema(description = "선종 코드 (AIS ship type)", example = "74")
+    private String shipType;
+
+    @Schema(
+        description = "선박 종류 코드 (000020:어선, 000021:함정, 000022:여객선, 000023:화물선, 000024:유조선, 000025:관공선, 000027:기타)",
+        example = "000023"
+    )
+    private String shipKindCode;
+
+    @Schema(
+        description = "통합선박 ID (동일 선박의 다중 신호원 통합 식별자)",
+        example = "440113620___440113620_"
+    )
+    private String integrationTargetId;
 }
diff --git a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/IntegrationVessel.java b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/IntegrationVessel.java
index f6ed9dc..fb34f0e 100644
--- a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/IntegrationVessel.java
+++ b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/IntegrationVessel.java
@@ -8,7 +8,7 @@ import lombok.NoArgsConstructor;
 
 /**
  * 통합선박 정보 DTO
- * gis.t_ship_integration_sub 테이블 매핑
+ * signal.t_ship_integration_sub 테이블 매핑
  */
 @Data
 @Builder
diff --git a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/RecentVesselPositionDto.java b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/RecentVesselPositionDto.java
index 12a6d74..79e0f51 100644
--- a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/RecentVesselPositionDto.java
+++ b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/RecentVesselPositionDto.java
@@ -16,37 +16,44 @@ import java.time.LocalDateTime;
 @AllArgsConstructor
 @Schema(description = "최근 위치 업데이트된 선박 정보")
 public class RecentVesselPositionDto {
-    @Schema(description = "신호원 코드", example = "000001")
+
+    @Schema(
+        description = "신호원 코드 (000001:AIS, 000002:LRIT, 000003:VPASS, 000004:VTS-AIS 등)",
+        example = "000001"
+    )
     private String sigSrcCd;
-    
-    @Schema(description = "대상 ID", example = "440331240")
+
+    @Schema(description = "대상 ID (MMSI: 9자리, 한국선박 440/441로 시작)", example = "440113620")
     private String targetId;
-    
-    @Schema(description = "경도", example = "126.9779")
+
+    @Schema(description = "경도 (WGS84)", example = "127.0638")
     private Double lon;
-    
-    @Schema(description = "위도", example = "37.5665")
+
+    @Schema(description = "위도 (WGS84)", example = "34.227527")
     private Double lat;
-    
-    @Schema(description = "대지속도 (knots)", example = "12.5")
+
+    @Schema(description = "대지속도 (knots)", example = "10.4")
     private BigDecimal sog;
-    
-    @Schema(description = "대지침로 (도)", example = "180.0")
+
+    @Schema(description = "대지침로 (도, 0~360)", example = "215.3")
     private BigDecimal cog;
-    
-    @Schema(description = "선박명", example = "SEOM SARANG 11")
+
+    @Schema(description = "선박명", example = "SAM SUNG 2HO")
     private String shipNm;
-    
-    @Schema(description = "선박 유형", example = "60")
+
+    @Schema(description = "선박 유형 (AIS ship type)", example = "74")
     private String shipTy;
-    
-    @Schema(description = "선박 종류 코드", example = "000022")
+
+    @Schema(
+        description = "선박 종류 코드 (000020:어선, 000022:여객선, 000023:화물선 등)",
+        example = "000023"
+    )
     private String shipKindCode;
-    
-    @Schema(description = "국가 코드", example = "440")
+
+    @Schema(description = "국가 코드 (MID 기반, KR=한국)", example = "KR")
     private String nationalCode;
-    
-    @Schema(description = "최종 업데이트 시간", example = "2025-08-28 15:30:00")
+
+    @Schema(description = "최종 업데이트 시간", example = "2026-01-20 12:05:00")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private LocalDateTime lastUpdate;
 }
\ No newline at end of file
diff --git a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/TrackResponse.java b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/TrackResponse.java
index 43cab6e..e7df90c 100644
--- a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/TrackResponse.java
+++ b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/TrackResponse.java
@@ -1,6 +1,7 @@
 package gc.mda.signal_batch.domain.vessel.dto;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Builder;
 import lombok.Data;
 
@@ -9,28 +10,44 @@ import java.time.LocalDateTime;
 
 @Data
 @Builder
+@Schema(description = "항적 세그먼트 (V1 API용, WKT 기반)")
 public class TrackResponse {
+
     @JsonProperty("sig_src_cd")
+    @Schema(
+        description = "신호 소스 코드 (000001:AIS, 000002:LRIT, 000003:VPASS, 000004:VTS-AIS 등)",
+        example = "000001"
+    )
     private String sigSrcCd;
-    
+
     @JsonProperty("target_id")
+    @Schema(description = "타겟 ID (MMSI: 9자리, 한국선박 440/441로 시작)", example = "440113620")
     private String targetId;
-    
+
     @JsonProperty("track_geom")
-    private String trackGeom; // WKT format
-    
+    @Schema(
+        description = "항적 geometry (WKT LineStringM 형식: X=경도, Y=위도, M=Unix timestamp)",
+        example = "LINESTRING M(127.0638 34.227527 1768878312, 127.063303 34.226685 1768878332, 127.063008 34.226203 1768878342)"
+    )
+    private String trackGeom;
+
     @JsonProperty("distance_nm")
+    @Schema(description = "이동거리 (해리)", example = "1.64")
     private BigDecimal distanceNm;
-    
+
     @JsonProperty("avg_speed")
+    @Schema(description = "평균 속도 (knots)", example = "10.54")
     private BigDecimal avgSpeed;
-    
+
     @JsonProperty("max_speed")
+    @Schema(description = "최대 속도 (knots)", example = "10.9")
     private BigDecimal maxSpeed;
-    
+
     @JsonProperty("point_count")
+    @Schema(description = "포인트 수", example = "38")
     private Integer pointCount;
-    
+
     @JsonProperty("time_bucket")
+    @Schema(description = "시간 버킷 (5분/1시간/1일 집계 단위)", example = "2026-01-20T12:00:00")
     private LocalDateTime timeBucket;
 }
diff --git a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselBucketPositionDto.java b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselBucketPositionDto.java
new file mode 100644
index 0000000..aab5ee7
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselBucketPositionDto.java
@@ -0,0 +1,56 @@
+package gc.mda.signal_batch.domain.vessel.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * 선박 버킷 종료 위치 DTO
+ *
+ * 용도: 버킷 간 점프 검출을 위한 이전 버킷 종료 위치 저장
+ *
+ * 데이터 흐름:
+ * 1. 5분 집계 완료 후 각 선박의 버킷 종료 위치 저장
+ * 2. 다음 버킷 처리 시 이전 위치와 비교하여 점프 검출
+ * 3. 캐시 미스 시 t_vessel_latest_position 테이블에서 fallback 조회
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class VesselBucketPositionDto {
+    /**
+     * 신호원 코드
+     */
+    private String sigSrcCd;
+
+    /**
+     * 대상 ID
+     */
+    private String targetId;
+
+    /**
+     * 경도 (버킷 종료 시점)
+     */
+    private Double endLon;
+
+    /**
+     * 위도 (버킷 종료 시점)
+     */
+    private Double endLat;
+
+    /**
+     * 버킷 종료 시간
+     */
+    private LocalDateTime endTime;
+
+    /**
+     * 선박 키 생성 (sigSrcCd:targetId)
+     */
+    public String getVesselKey() {
+        return sigSrcCd + ":" + targetId;
+    }
+}
diff --git a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselStatsResponse.java b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselStatsResponse.java
index 34c63a7..342ec87 100644
--- a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselStatsResponse.java
+++ b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselStatsResponse.java
@@ -1,6 +1,7 @@
 package gc.mda.signal_batch.domain.vessel.dto;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Builder;
 import lombok.Data;
 
@@ -8,16 +9,22 @@ import java.math.BigDecimal;
 
 @Data
 @Builder
+@Schema(description = "해구/영역별 선박 통계")
 public class VesselStatsResponse {
+
     @JsonProperty("vessel_count")
+    @Schema(description = "고유 선박 수 (해당 영역 내 탐지된 선박)", example = "156")
     private Integer vesselCount;
-    
+
     @JsonProperty("total_distance")
+    @Schema(description = "총 이동거리 (해리, 모든 선박 합산)", example = "1248.73")
     private BigDecimal totalDistance;
-    
+
     @JsonProperty("avg_speed")
+    @Schema(description = "평균 속도 (knots)", example = "10.54")
     private BigDecimal avgSpeed;
-    
+
     @JsonProperty("active_tracks")
+    @Schema(description = "활성 항적 수 (현재 이동 중인 선박)", example = "89")
     private Integer activeTracks;
 }
diff --git a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselTracksRequest.java b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselTracksRequest.java
index 7dd5e97..481b9aa 100644
--- a/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselTracksRequest.java
+++ b/src/main/java/gc/mda/signal_batch/domain/vessel/dto/VesselTracksRequest.java
@@ -1,5 +1,8 @@
 package gc.mda.signal_batch.domain.vessel.dto;
 
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import gc.mda.signal_batch.global.config.FlexibleLocalDateTimeDeserializer;
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.Builder;
 import lombok.AllArgsConstructor;
@@ -12,25 +15,63 @@ import java.util.List;
 @Builder
 @AllArgsConstructor
 @NoArgsConstructor
+@Schema(description = "선박별 항적 조회 요청")
 public class VesselTracksRequest {
+
+    @Schema(
+        description = """
+            조회 시작 시간.
+            지원 형식: ISO 8601 (2026-01-20T12:00:00), UTC (2026-01-20T12:00:00Z),
+            표준 형식 (2026-01-20 12:00:00), 압축 형식 (20260120120000)
+            """,
+        example = "2026-01-20T12:00:00",
+        required = true
+    )
+    @JsonDeserialize(using = FlexibleLocalDateTimeDeserializer.class)
     private LocalDateTime startTime;
+
+    @Schema(
+        description = """
+            조회 종료 시간.
+            지원 형식: ISO 8601 (2026-01-20T12:10:00), UTC (2026-01-20T12:10:00Z),
+            표준 형식 (2026-01-20 12:10:00), 압축 형식 (20260120121000)
+            """,
+        example = "2026-01-20T12:10:00",
+        required = true
+    )
+    @JsonDeserialize(using = FlexibleLocalDateTimeDeserializer.class)
     private LocalDateTime endTime;
+
+    @Schema(description = "조회할 선박 목록", required = true)
     private List<VesselIdentifier> vessels;
 
-    /**
-     * 통합선박신호 모드
-     * "0": 기본 모드 - 전체 항적 반환 (기본값)
-     * "1": 통합 모드 - 동일 선박의 여러 신호 중 최고 우선순위만 반환
-     */
+    @Schema(
+        description = "통합선박 필터링 모드 (0: 전체 항적, 1: 통합선박 우선순위 적용)",
+        example = "0",
+        allowableValues = {"0", "1"}
+    )
     @Builder.Default
     private String isIntegration = "0";
-    
+
     @Data
     @Builder
     @AllArgsConstructor
     @NoArgsConstructor
+    @Schema(description = "선박 식별자")
     public static class VesselIdentifier {
+
+        @Schema(
+            description = "신호 소스 코드 (000001:AIS, 000002:LRIT, 000003:VPASS, 000004:VTS-AIS, 000019:항공기 등)",
+            example = "000001",
+            required = true
+        )
         private String sigSrcCd;
+
+        @Schema(
+            description = "타겟 ID (MMSI: 9자리, 한국선박 440/441로 시작)",
+            example = "440113620",
+            required = true
+        )
         private String targetId;
     }
 }
diff --git a/src/main/java/gc/mda/signal_batch/domain/vessel/service/IntegrationVesselService.java b/src/main/java/gc/mda/signal_batch/domain/vessel/service/IntegrationVesselService.java
index 5f3989b..4cfe261 100644
--- a/src/main/java/gc/mda/signal_batch/domain/vessel/service/IntegrationVesselService.java
+++ b/src/main/java/gc/mda/signal_batch/domain/vessel/service/IntegrationVesselService.java
@@ -167,7 +167,7 @@ public class IntegrationVesselService {
                 SELECT intgr_seq, ais, enav, vpass, vts_ais, d_mf_hf,
                        ais_ship_nm, enav_ship_nm, vpass_ship_nm, vts_ais_ship_nm, d_mf_hf_ship_nm,
                        integration_ship_ty
-                FROM gis.t_ship_integration_sub
+                FROM signal.t_ship_integration_sub
                 """;
 
             List<IntegrationVessel> vessels = jdbcTemplate.query(sql, (rs, rowNum) ->
diff --git a/src/main/java/gc/mda/signal_batch/domain/vessel/service/VesselPreviousBucketCache.java b/src/main/java/gc/mda/signal_batch/domain/vessel/service/VesselPreviousBucketCache.java
new file mode 100644
index 0000000..d088218
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/domain/vessel/service/VesselPreviousBucketCache.java
@@ -0,0 +1,303 @@
+package gc.mda.signal_batch.domain.vessel.service;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import gc.mda.signal_batch.domain.vessel.dto.VesselBucketPositionDto;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.caffeine.CaffeineCache;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.stereotype.Service;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * 선박 이전 버킷 종료 위치 캐시 관리 서비스
+ *
+ * 용도: 버킷 간 점프 검출을 위한 이전 버킷 종료 위치 캐싱
+ *
+ * 캐시 구조:
+ * - Key: "{sigSrcCd}:{targetId}" (예: "000001:440123456")
+ * - Value: VesselBucketPositionDto (endLon, endLat, endTime)
+ * - TTL: 120분 (위성 AIS 고려)
+ *
+ * 데이터 흐름:
+ * 1. 5분 집계 시작 시 캐시에서 이전 버킷 위치 조회
+ * 2. 캐시 미스 시 t_vessel_latest_position 테이블에서 최근 2시간 데이터 조회 (fallback)
+ * 3. 현재 버킷과 이전 버킷 간 점프 검출
+ * 4. 처리 완료 후 현재 버킷 종료 위치를 캐시에 업데이트
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class VesselPreviousBucketCache {
+
+    private final CacheManager cacheManager;
+
+    @Qualifier("queryJdbcTemplate")
+    private final JdbcTemplate queryJdbcTemplate;
+
+    private static final String CACHE_NAME = "vesselPreviousBuckets";
+
+    // DB 전체 조회 중복 방지 플래그
+    private volatile boolean fallbackLoaded = false;
+
+    // DB 조회 통계
+    private volatile int totalDbQueriesCount = 0;
+    private volatile int totalVesselsLoadedFromDb = 0;
+
+    /**
+     * 캐시 키 생성
+     */
+    private String createKey(String sigSrcCd, String targetId) {
+        return sigSrcCd + ":" + targetId;
+    }
+
+    /**
+     * 단일 선박의 버킷 종료 위치 조회
+     *
+     * @param sigSrcCd 신호원 코드
+     * @param targetId 대상 ID
+     * @return 이전 버킷 종료 위치 (캐시 미스 시 null)
+     */
+    public VesselBucketPositionDto get(String sigSrcCd, String targetId) {
+        String key = createKey(sigSrcCd, targetId);
+        org.springframework.cache.Cache cache = getCache();
+
+        if (cache != null) {
+            org.springframework.cache.Cache.ValueWrapper wrapper = cache.get(key);
+            if (wrapper != null && wrapper.get() instanceof VesselBucketPositionDto) {
+                return (VesselBucketPositionDto) wrapper.get();
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * 여러 선박의 이전 버킷 위치 일괄 조회 (캐시 + DB Fallback)
+     *
+     * @param vesselKeys 조회할 선박 키 목록 (sigSrcCd:targetId)
+     * @return 선박 키 -> 이전 버킷 위치 매핑
+     */
+    public Map<String, VesselBucketPositionDto> getBatch(List<String> vesselKeys) {
+        Map<String, VesselBucketPositionDto> result = new HashMap<>();
+
+        if (vesselKeys == null || vesselKeys.isEmpty()) {
+            return result;
+        }
+
+        ConcurrentMap<Object, Object> nativeCache = getNativeCache();
+        int cacheHits = 0;
+        int cacheMisses = 0;
+
+        // 1. 캐시에서 조회
+        for (String vesselKey : vesselKeys) {
+            if (nativeCache != null && nativeCache.containsKey(vesselKey)) {
+                Object value = nativeCache.get(vesselKey);
+                if (value instanceof VesselBucketPositionDto position) {
+                    result.put(vesselKey, position);
+                    cacheHits++;
+                }
+            } else {
+                cacheMisses++;
+            }
+        }
+
+        // 캐시 조회 로그 제거 (Job 레벨 통계로 대체)
+
+        // 2. 캐시 미스 시 DB에서 일괄 조회 (최근 2시간) - 첫 실행 시 1회만
+        if (cacheMisses > 0 && !fallbackLoaded) {
+            synchronized (this) {
+                if (!fallbackLoaded) {
+                    long startTime = System.currentTimeMillis();
+                    Map<String, VesselBucketPositionDto> dbResults = loadFromDatabaseBatch();
+                    long elapsed = System.currentTimeMillis() - startTime;
+
+                    // 전체 결과를 캐시에 저장 (요청 여부와 관계없이 모두 저장)
+                    dbResults.values().forEach(this::put);
+
+                    // 요청된 선박들을 결과에 추가
+                    for (String vesselKey : vesselKeys) {
+                        if (!result.containsKey(vesselKey) && dbResults.containsKey(vesselKey)) {
+                            result.put(vesselKey, dbResults.get(vesselKey));
+                        }
+                    }
+
+                    totalDbQueriesCount++;
+                    totalVesselsLoadedFromDb += dbResults.size();
+                    fallbackLoaded = true;
+
+                    log.info("Previous bucket cache initialized: loaded {} vessels from DB in {}ms",
+                            dbResults.size(), elapsed);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * DB에서 최근 2시간 데이터 일괄 조회 (Fallback)
+     */
+    private Map<String, VesselBucketPositionDto> loadFromDatabaseBatch() {
+        Map<String, VesselBucketPositionDto> result = new HashMap<>();
+
+        // t_vessel_latest_position 테이블에서 최근 2시간 데이터 조회
+        String sql = """
+            SELECT
+                sig_src_cd,
+                target_id,
+                lon,
+                lat,
+                last_update
+            FROM signal.t_vessel_latest_position
+            WHERE last_update >= NOW() - INTERVAL '2 hours'
+                AND sig_src_cd NOT IN ('000004', '000005')
+            """;
+
+        try {
+            List<VesselBucketPositionDto> positions = queryJdbcTemplate.query(sql, new BucketPositionRowMapper());
+
+            for (VesselBucketPositionDto position : positions) {
+                result.put(position.getVesselKey(), position);
+            }
+
+            log.debug("Queried {} vessel positions from t_vessel_latest_position (last 2 hours)", positions.size());
+
+        } catch (Exception e) {
+            log.error("Failed to load previous bucket positions from DB", e);
+        }
+
+        return result;
+    }
+
+    /**
+     * 단일 선박 위치 캐시 저장
+     */
+    public void put(VesselBucketPositionDto position) {
+        if (position == null || position.getSigSrcCd() == null || position.getTargetId() == null) {
+            log.warn("Invalid position data, skipping cache: {}", position);
+            return;
+        }
+
+        String key = createKey(position.getSigSrcCd(), position.getTargetId());
+        getCache().put(key, position);
+    }
+
+    /**
+     * 여러 선박 위치 일괄 캐시 저장
+     */
+    public void putAll(List<VesselBucketPositionDto> positions) {
+        if (positions == null || positions.isEmpty()) {
+            log.debug("No positions to cache");
+            return;
+        }
+
+        int count = 0;
+        for (VesselBucketPositionDto position : positions) {
+            if (position.getSigSrcCd() != null && position.getTargetId() != null) {
+                put(position);
+                count++;
+            }
+        }
+
+        log.debug("Cached {} vessel bucket positions (Total cache size: {})",
+                count, getCacheSize());
+    }
+
+    /**
+     * 캐시 전체 삭제
+     */
+    public void clear() {
+        org.springframework.cache.Cache cache = getCache();
+        if (cache != null) {
+            cache.clear();
+            fallbackLoaded = false;
+            log.info("Previous bucket cache cleared");
+        }
+    }
+
+    /**
+     * Job 시작 시 플래그 리셋
+     */
+    public void resetFallbackFlag() {
+        fallbackLoaded = false;
+        totalDbQueriesCount = 0;
+        totalVesselsLoadedFromDb = 0;
+        log.debug("Fallback flag and statistics reset");
+    }
+
+    /**
+     * Job 완료 시 통계 출력
+     */
+    public void logJobStatistics() {
+        if (totalDbQueriesCount > 0) {
+            log.info("Bucket jump detection stats - Cache size: {}, DB queries: {}, Vessels loaded: {}",
+                    getCacheSize(), totalDbQueriesCount, totalVesselsLoadedFromDb);
+        }
+    }
+
+    /**
+     * Spring Cache 객체 가져오기
+     */
+    private org.springframework.cache.Cache getCache() {
+        return cacheManager.getCache(CACHE_NAME);
+    }
+
+    /**
+     * Caffeine Cache 네이티브 객체 가져오기
+     */
+    private Cache<Object, Object> getCaffeineCache() {
+        org.springframework.cache.Cache cache = getCache();
+        if (cache instanceof CaffeineCache caffeineCache) {
+            return caffeineCache.getNativeCache();
+        }
+        return null;
+    }
+
+    /**
+     * ConcurrentMap 가져오기 (배치 조회용)
+     */
+    private ConcurrentMap<Object, Object> getNativeCache() {
+        Cache<Object, Object> caffeineCache = getCaffeineCache();
+        if (caffeineCache != null) {
+            return caffeineCache.asMap();
+        }
+        return null;
+    }
+
+    /**
+     * 현재 캐시 크기 조회
+     */
+    private int getCacheSize() {
+        ConcurrentMap<Object, Object> nativeCache = getNativeCache();
+        return nativeCache != null ? nativeCache.size() : 0;
+    }
+
+    /**
+     * RowMapper 구현
+     */
+    private static class BucketPositionRowMapper implements RowMapper<VesselBucketPositionDto> {
+        @Override
+        public VesselBucketPositionDto mapRow(ResultSet rs, int rowNum) throws SQLException {
+            return VesselBucketPositionDto.builder()
+                    .sigSrcCd(rs.getString("sig_src_cd"))
+                    .targetId(rs.getString("target_id"))
+                    .endLon(rs.getDouble("lon"))
+                    .endLat(rs.getDouble("lat"))
+                    .endTime(rs.getTimestamp("last_update") != null ?
+                            rs.getTimestamp("last_update").toLocalDateTime() : null)
+                    .build();
+        }
+    }
+}
diff --git a/src/main/java/gc/mda/signal_batch/global/config/BatchConfig.java b/src/main/java/gc/mda/signal_batch/global/config/BatchConfig.java
index b1495ca..4b0c156 100644
--- a/src/main/java/gc/mda/signal_batch/global/config/BatchConfig.java
+++ b/src/main/java/gc/mda/signal_batch/global/config/BatchConfig.java
@@ -1,17 +1,18 @@
 package gc.mda.signal_batch.global.config;
 
 import org.springframework.batch.core.configuration.JobRegistry;
-import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
+import org.springframework.batch.core.configuration.support.DefaultBatchConfiguration;
 import org.springframework.batch.core.configuration.support.JobRegistryBeanPostProcessor;
-import org.springframework.batch.core.explore.JobExplorer;
-import org.springframework.batch.core.explore.support.JobExplorerFactoryBean;
 import org.springframework.batch.core.launch.JobLauncher;
 import org.springframework.batch.core.launch.support.TaskExecutorJobLauncher;
 import org.springframework.batch.core.repository.JobRepository;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.context.annotation.Profile;
 import org.springframework.core.task.TaskExecutor;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
@@ -21,10 +22,37 @@ import javax.sql.DataSource;
 import java.util.concurrent.ThreadPoolExecutor;
 
 @Configuration
-@EnableBatchProcessing
 @Profile("!query")  // query 프로파일에서는 배치 처리 비활성화
 @ConditionalOnProperty(name = "vessel.batch.scheduler.enabled", havingValue = "true", matchIfMissing = true)
-public class BatchConfig {
+public class BatchConfig extends DefaultBatchConfiguration {
+
+    @Value("${spring.batch.jdbc.table-prefix:BATCH_}")
+    private String tablePrefix;
+
+    @Autowired
+    @Qualifier("batchDataSource")
+    @Lazy
+    private DataSource batchDataSource;
+
+    @Autowired
+    @Qualifier("batchTransactionManager")
+    @Lazy
+    private PlatformTransactionManager batchTransactionManager;
+
+    @Override
+    protected DataSource getDataSource() {
+        return batchDataSource;
+    }
+
+    @Override
+    protected PlatformTransactionManager getTransactionManager() {
+        return batchTransactionManager;
+    }
+
+    @Override
+    protected String getTablePrefix() {
+        return tablePrefix;
+    }
 
     @Bean
     public TaskExecutor batchTaskExecutor() {
@@ -77,14 +105,4 @@ public class BatchConfig {
         postProcessor.setJobRegistry(jobRegistry);
         return postProcessor;
     }
-
-    @Bean
-    public JobExplorer jobExplorer(@Qualifier("batchDataSource") DataSource dataSource,
-                                   @Qualifier("batchTransactionManager") PlatformTransactionManager transactionManager) throws Exception {
-        JobExplorerFactoryBean factory = new JobExplorerFactoryBean();
-        factory.setDataSource(dataSource);
-        factory.setTransactionManager(transactionManager);
-        factory.afterPropertiesSet();
-        return factory.getObject();
-    }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/gc/mda/signal_batch/global/config/CacheConfig.java b/src/main/java/gc/mda/signal_batch/global/config/CacheConfig.java
index 7a7731b..76feb32 100644
--- a/src/main/java/gc/mda/signal_batch/global/config/CacheConfig.java
+++ b/src/main/java/gc/mda/signal_batch/global/config/CacheConfig.java
@@ -32,21 +32,40 @@ public class CacheConfig {
     @Value("${vessel.batch.cache.latest-position.max-size:50000}")
     private int cacheMaxSize;
 
+    @Value("${vessel.batch.cache.previous-bucket.ttl-minutes:120}")
+    private int previousBucketTtlMinutes;
+
+    @Value("${vessel.batch.cache.previous-bucket.max-size:50000}")
+    private int previousBucketMaxSize;
+
     @Bean
     public CacheManager cacheManager() {
-        CaffeineCacheManager cacheManager = new CaffeineCacheManager("vesselLatestPositions");
-        cacheManager.setCaffeine(caffeineCacheBuilder());
+        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
 
-        log.info("Initialized Caffeine CacheManager with TTL={}min, MaxSize={}",
-                cacheTtlMinutes, cacheMaxSize);
+        // 1. vesselLatestPositions 캐시 (최신 위치 API용)
+        cacheManager.registerCustomCache("vesselLatestPositions",
+            latestPositionCacheBuilder().build());
+
+        // 2. vesselPreviousBuckets 캐시 (버킷 점프 검출용)
+        cacheManager.registerCustomCache("vesselPreviousBuckets",
+            previousBucketCacheBuilder().build());
+
+        log.info("Initialized Caffeine CacheManager:");
+        log.info("  - vesselLatestPositions: TTL={}min, MaxSize={}", cacheTtlMinutes, cacheMaxSize);
+        log.info("  - vesselPreviousBuckets: TTL={}min, MaxSize={}", previousBucketTtlMinutes, previousBucketMaxSize);
 
         return cacheManager;
     }
 
-    private Caffeine<Object, Object> caffeineCacheBuilder() {
+    /**
+     * 최신 위치 캐시 빌더 (API 응답용)
+     */
+    private Caffeine<Object, Object> latestPositionCacheBuilder() {
         return Caffeine.newBuilder()
-                // TTL: 60분 후 자동 만료 (비활성 선박 제거)
-                .expireAfterWrite(cacheTtlMinutes, TimeUnit.MINUTES)
+                // TTL: 마지막 접근 후 60분 (읽기/쓰기 시 리셋)
+                // - 활성 선박: API 조회 또는 스케줄러 갱신 → TTL 계속 리셋
+                // - 비활성 선박: 60분 미접근 → 자동 제거
+                .expireAfterAccess(cacheTtlMinutes, TimeUnit.MINUTES)
 
                 // 최대 선박 수 제한 (메모리 보호)
                 .maximumSize(cacheMaxSize)
@@ -57,4 +76,24 @@ public class CacheConfig {
                 // 초기 용량 설정 (rehashing 최소화)
                 .initialCapacity(1000);
     }
+
+    /**
+     * 이전 버킷 위치 캐시 빌더 (버킷 점프 검출용)
+     */
+    private Caffeine<Object, Object> previousBucketCacheBuilder() {
+        return Caffeine.newBuilder()
+                // TTL: 마지막 접근 후 120분 (읽기/쓰기 시 리셋)
+                // - 활성 선박: 5분마다 접근 → TTL 계속 갱신 → 영구 유지
+                // - 비활성 선박: 120분 미접근 → 자동 제거
+                .expireAfterAccess(previousBucketTtlMinutes, TimeUnit.MINUTES)
+
+                // 최대 선박 수 제한
+                .maximumSize(previousBucketMaxSize)
+
+                // 통계 수집 활성화
+                .recordStats()
+
+                // 초기 용량 설정
+                .initialCapacity(1000);
+    }
 }
diff --git a/src/main/java/gc/mda/signal_batch/global/config/DataSourceConfigProperties.java b/src/main/java/gc/mda/signal_batch/global/config/DataSourceConfigProperties.java
index 402d197..a7cf0b6 100644
--- a/src/main/java/gc/mda/signal_batch/global/config/DataSourceConfigProperties.java
+++ b/src/main/java/gc/mda/signal_batch/global/config/DataSourceConfigProperties.java
@@ -6,7 +6,7 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Profile;
 
 @Configuration
-@Profile("prod")
+@Profile({"prod", "prod-mpr", "dev", "local"})
 @ConfigurationProperties(prefix = "spring.datasource")
 @Data
 public class DataSourceConfigProperties {
diff --git a/src/main/java/gc/mda/signal_batch/global/config/FlexibleLocalDateTimeDeserializer.java b/src/main/java/gc/mda/signal_batch/global/config/FlexibleLocalDateTimeDeserializer.java
new file mode 100644
index 0000000..2e56564
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/global/config/FlexibleLocalDateTimeDeserializer.java
@@ -0,0 +1,47 @@
+package gc.mda.signal_batch.global.config;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import gc.mda.signal_batch.global.util.DateTimeParseUtil;
+
+import java.io.IOException;
+import java.time.LocalDateTime;
+
+/**
+ * 다양한 날짜/시간 형식을 지원하는 Jackson Deserializer
+ *
+ * <p>지원 형식:</p>
+ * <ul>
+ *   <li>ISO 8601: 2026-01-20T10:00:00</li>
+ *   <li>ISO 8601 (UTC): 2026-01-20T10:00:00Z</li>
+ *   <li>ISO 8601 (Offset): 2026-01-20T10:00:00+09:00</li>
+ *   <li>표준 형식: 2026-01-20 10:00:00</li>
+ *   <li>초 생략: 2026-01-20T10:00, 2026-01-20 10:00</li>
+ *   <li>압축 형식: 20260120100000</li>
+ * </ul>
+ *
+ * <p>사용 예:</p>
+ * <pre>{@code
+ * @JsonDeserialize(using = FlexibleLocalDateTimeDeserializer.class)
+ * private LocalDateTime startTime;
+ * }</pre>
+ *
+ * @see DateTimeParseUtil
+ */
+public class FlexibleLocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
+
+    @Override
+    public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
+        String value = p.getValueAsString();
+        if (value == null || value.isBlank()) {
+            return null;
+        }
+
+        try {
+            return DateTimeParseUtil.parse(value);
+        } catch (IllegalArgumentException e) {
+            throw new IOException("날짜/시간 파싱 실패: " + value + ". " + e.getMessage(), e);
+        }
+    }
+}
diff --git a/src/main/java/gc/mda/signal_batch/global/config/ProdDataSourceConfig.java b/src/main/java/gc/mda/signal_batch/global/config/ProdDataSourceConfig.java
index 9b62d2c..3173f01 100644
--- a/src/main/java/gc/mda/signal_batch/global/config/ProdDataSourceConfig.java
+++ b/src/main/java/gc/mda/signal_batch/global/config/ProdDataSourceConfig.java
@@ -15,7 +15,7 @@ import org.springframework.transaction.PlatformTransactionManager;
 import javax.sql.DataSource;
 
 @Configuration
-@Profile("prod")
+@Profile({"prod", "prod-mpr"})
 public class ProdDataSourceConfig {
 
     private final DataSourceConfigProperties properties;
diff --git a/src/main/java/gc/mda/signal_batch/global/config/SwaggerConfig.java b/src/main/java/gc/mda/signal_batch/global/config/SwaggerConfig.java
index b3485de..f9de431 100644
--- a/src/main/java/gc/mda/signal_batch/global/config/SwaggerConfig.java
+++ b/src/main/java/gc/mda/signal_batch/global/config/SwaggerConfig.java
@@ -57,15 +57,15 @@ import org.springframework.context.annotation.Configuration;
             ```
             """,
         contact = @Contact(
-            name = "Signal Batch Team",
-            email = "signal-batch@mda.gc"
+            name = "GC MDA Team",
+            email = "htlee@gcsc.co.kr"
         ),
         license = @License(
             name = "Internal Use Only"
         )
     ),
     servers = {
-            @Server(url = "http://10.26.252.48:8090", description = "Development Server (QueryDB)"),
+            @Server(url = "http://10.26.252.51:8090", description = "Development Server (QueryDB)"),
             @Server(url = "http://10.26.252.39:8090", description = "Production Server"),
             @Server(url = "http://localhost:8090", description = "Local Development Server")
     }
@@ -77,14 +77,27 @@ public class SwaggerConfig {
         return GroupedOpenApi.builder()
                 .group("1-track-api")
                 .displayName("항적 조회 API")
-                .pathsToMatch("/api/v1/tracks/**", "/api/v1/haegu/**", "/api/v1/areas/**", "/api/v1/passages/**", "/api/v1/vessels/**")
+                .pathsToMatch(
+                    "/api/v1/tracks/**", "/api/v1/haegu/**", "/api/v1/areas/**",
+                    "/api/v1/passages/**", "/api/v1/vessels/**",
+                    "/api/v2/**"
+                )
+                .build();
+    }
+
+    @Bean
+    public GroupedOpenApi shipImageApi() {
+        return GroupedOpenApi.builder()
+                .group("2-ship-image-api")
+                .displayName("선박 이미지 API")
+                .pathsToMatch("/api/v1/shipimg/**")
                 .build();
     }
 
     @Bean
     public GroupedOpenApi abnormalTrackApi() {
         return GroupedOpenApi.builder()
-                .group("2-abnormal-track-api")
+                .group("3-abnormal-track-api")
                 .displayName("비정상 항적 검출 API")
                 .pathsToMatch("/api/v1/abnormal-tracks/**")
                 .build();
@@ -93,7 +106,7 @@ public class SwaggerConfig {
     @Bean
     public GroupedOpenApi tileApi() {
         return GroupedOpenApi.builder()
-                .group("3-tile-api")
+                .group("4-tile-api")
                 .displayName("타일 집계 API")
                 .pathsToMatch("/api/v1/tiles/**", "/api/tiles/**")
                 .build();
@@ -102,7 +115,7 @@ public class SwaggerConfig {
     @Bean
     public GroupedOpenApi performanceApi() {
         return GroupedOpenApi.builder()
-                .group("4-performance-api")
+                .group("5-performance-api")
                 .displayName("성능 최적화 API")
                 .pathsToMatch("/api/v1/performance/**")
                 .build();
@@ -111,7 +124,7 @@ public class SwaggerConfig {
     @Bean
     public GroupedOpenApi adminApi() {
         return GroupedOpenApi.builder()
-                .group("5-admin-api")
+                .group("6-admin-api")
                 .displayName("관리자 API")
                 .pathsToMatch("/admin/**")
                 .build();
@@ -120,9 +133,27 @@ public class SwaggerConfig {
     @Bean
     public GroupedOpenApi monitoringApi() {
         return GroupedOpenApi.builder()
-                .group("6-monitoring-api")
+                .group("7-monitoring-api")
                 .displayName("모니터링 API")
-                .pathsToMatch("/monitor/**", "/actuator/**", "/api/websocket/**")
+                .pathsToMatch("/monitor/**", "/actuator/**", "/api/websocket/**", "/api/monitoring/**")
+                .build();
+    }
+
+    @Bean
+    public GroupedOpenApi migrationApi() {
+        return GroupedOpenApi.builder()
+                .group("8-migration-api")
+                .displayName("마이그레이션 API")
+                .pathsToMatch("/api/migration/**")
+                .build();
+    }
+
+    @Bean
+    public GroupedOpenApi debugApi() {
+        return GroupedOpenApi.builder()
+                .group("9-debug-api")
+                .displayName("디버그 API")
+                .pathsToMatch("/api/debug/**")
                 .build();
     }
 }
\ No newline at end of file
diff --git a/src/main/java/gc/mda/signal_batch/global/util/DateTimeParseUtil.java b/src/main/java/gc/mda/signal_batch/global/util/DateTimeParseUtil.java
new file mode 100644
index 0000000..d6648e1
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/global/util/DateTimeParseUtil.java
@@ -0,0 +1,176 @@
+package gc.mda.signal_batch.global.util;
+
+import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 다양한 날짜/시간 형식을 파싱하는 유틸리티 클래스
+ *
+ * <p>지원 형식:</p>
+ * <ul>
+ *   <li>ISO 8601 (T 포함): 2026-01-20T10:00:00</li>
+ *   <li>ISO 8601 with timezone: 2026-01-20T10:00:00Z, 2026-01-20T10:00:00+09:00</li>
+ *   <li>표준 형식 (공백 구분): 2026-01-20 10:00:00</li>
+ *   <li>초 생략 형식: 2026-01-20T10:00, 2026-01-20 10:00</li>
+ *   <li>압축 형식: 20260120100000 (YYYYMMDDHHMMSS)</li>
+ *   <li>압축 형식 (초 생략): 202601201000 (YYYYMMDDHHMM)</li>
+ * </ul>
+ *
+ * <p>사용 예:</p>
+ * <pre>{@code
+ * LocalDateTime dt1 = DateTimeParseUtil.parse("2026-01-20T10:00:00");
+ * LocalDateTime dt2 = DateTimeParseUtil.parse("2026-01-20 10:00:00");
+ * LocalDateTime dt3 = DateTimeParseUtil.parse("20260120100000");
+ * }</pre>
+ */
+public class DateTimeParseUtil {
+
+    /**
+     * 지원하는 날짜/시간 형식 목록 (우선순위 순)
+     */
+    private static final List<DateTimeFormatter> FORMATTERS = Arrays.asList(
+            // ISO 8601 with timezone (Z or offset)
+            DateTimeFormatter.ISO_ZONED_DATE_TIME,
+            DateTimeFormatter.ISO_OFFSET_DATE_TIME,
+            // ISO 8601 standard
+            DateTimeFormatter.ISO_LOCAL_DATE_TIME,
+            // Standard format with space
+            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"),
+            // Without seconds
+            DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm"),
+            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"),
+            // Compact format (YYYYMMDDHHMMSS)
+            DateTimeFormatter.ofPattern("yyyyMMddHHmmss"),
+            // Compact format without seconds (YYYYMMDDHHMM)
+            DateTimeFormatter.ofPattern("yyyyMMddHHmm")
+    );
+
+    /**
+     * Timezone 포함 형식 판별용
+     */
+    private static final List<DateTimeFormatter> ZONED_FORMATTERS = Arrays.asList(
+            DateTimeFormatter.ISO_ZONED_DATE_TIME,
+            DateTimeFormatter.ISO_OFFSET_DATE_TIME
+    );
+
+    private DateTimeParseUtil() {
+        // Utility class - prevent instantiation
+    }
+
+    /**
+     * 다양한 형식의 날짜/시간 문자열을 LocalDateTime으로 파싱
+     *
+     * @param dateTimeString 파싱할 날짜/시간 문자열
+     * @return 파싱된 LocalDateTime
+     * @throws IllegalArgumentException 지원하지 않는 형식인 경우
+     */
+    public static LocalDateTime parse(String dateTimeString) {
+        if (dateTimeString == null || dateTimeString.isBlank()) {
+            throw new IllegalArgumentException("날짜/시간 문자열이 null이거나 비어있습니다.");
+        }
+
+        String trimmed = dateTimeString.trim();
+
+        // Try zoned formatters first for Z or offset patterns
+        if (trimmed.contains("Z") || trimmed.matches(".*[+-]\\d{2}:\\d{2}$")) {
+            for (DateTimeFormatter formatter : ZONED_FORMATTERS) {
+                try {
+                    ZonedDateTime zdt = ZonedDateTime.parse(trimmed, formatter);
+                    return zdt.toLocalDateTime();
+                } catch (DateTimeParseException ignored) {
+                    // Try next formatter
+                }
+            }
+        }
+
+        // Try other formatters
+        for (DateTimeFormatter formatter : FORMATTERS) {
+            if (ZONED_FORMATTERS.contains(formatter)) {
+                continue; // Skip zoned formatters already tried
+            }
+            try {
+                return LocalDateTime.parse(trimmed, formatter);
+            } catch (DateTimeParseException ignored) {
+                // Try next formatter
+            }
+        }
+
+        throw new IllegalArgumentException(
+                "지원하지 않는 날짜/시간 형식입니다: " + dateTimeString + "\n" +
+                "지원 형식: ISO 8601 (2026-01-20T10:00:00, 2026-01-20T10:00:00Z), " +
+                "표준 형식 (2026-01-20 10:00:00), 압축 형식 (20260120100000)"
+        );
+    }
+
+    /**
+     * 날짜/시간 문자열 파싱 시도 (실패 시 null 반환)
+     *
+     * @param dateTimeString 파싱할 날짜/시간 문자열
+     * @return 파싱된 LocalDateTime 또는 null
+     */
+    public static LocalDateTime parseOrNull(String dateTimeString) {
+        try {
+            return parse(dateTimeString);
+        } catch (IllegalArgumentException e) {
+            return null;
+        }
+    }
+
+    /**
+     * 날짜/시간 문자열이 파싱 가능한지 확인
+     *
+     * @param dateTimeString 확인할 날짜/시간 문자열
+     * @return 파싱 가능 여부
+     */
+    public static boolean isValid(String dateTimeString) {
+        return parseOrNull(dateTimeString) != null;
+    }
+
+    /**
+     * LocalDateTime을 ISO 8601 형식으로 포맷
+     *
+     * @param dateTime 포맷할 LocalDateTime
+     * @return ISO 8601 형식 문자열 (예: 2026-01-20T10:00:00)
+     */
+    public static String formatIso(LocalDateTime dateTime) {
+        if (dateTime == null) {
+            return null;
+        }
+        return dateTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
+    }
+
+    /**
+     * LocalDateTime을 표준 형식으로 포맷
+     *
+     * @param dateTime 포맷할 LocalDateTime
+     * @return 표준 형식 문자열 (예: 2026-01-20 10:00:00)
+     */
+    public static String formatStandard(LocalDateTime dateTime) {
+        if (dateTime == null) {
+            return null;
+        }
+        return dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+    }
+
+    /**
+     * 지원 형식 설명 문자열 반환 (API 문서용)
+     *
+     * @return 지원 형식 설명
+     */
+    public static String getSupportedFormatsDescription() {
+        return """
+            지원 형식:
+            • ISO 8601: 2026-01-20T10:00:00
+            • ISO 8601 (UTC): 2026-01-20T10:00:00Z
+            • ISO 8601 (Offset): 2026-01-20T10:00:00+09:00
+            • 표준 형식: 2026-01-20 10:00:00
+            • 초 생략: 2026-01-20T10:00, 2026-01-20 10:00
+            • 압축 형식: 20260120100000 (YYYYMMDDHHMMSS)
+            • 압축 형식 (초 생략): 202601201000 (YYYYMMDDHHMM)
+            """;
+    }
+}
diff --git a/src/main/java/gc/mda/signal_batch/global/util/PartitionManager.java b/src/main/java/gc/mda/signal_batch/global/util/PartitionManager.java
index 162de21..40ab556 100644
--- a/src/main/java/gc/mda/signal_batch/global/util/PartitionManager.java
+++ b/src/main/java/gc/mda/signal_batch/global/util/PartitionManager.java
@@ -26,20 +26,28 @@ import java.util.stream.IntStream;
 public class PartitionManager {
 
     private final JdbcTemplate queryJdbcTemplate;
+    private final JdbcTemplate collectJdbcTemplate;
     private final gc.mda.signal_batch.global.config.PartitionRetentionConfig retentionConfig;
 
     public PartitionManager(
             @Qualifier("queryJdbcTemplate") JdbcTemplate queryJdbcTemplate,
+            @Qualifier("collectJdbcTemplate") JdbcTemplate collectJdbcTemplate,
             gc.mda.signal_batch.global.config.PartitionRetentionConfig retentionConfig) {
         this.queryJdbcTemplate = queryJdbcTemplate;
+        this.collectJdbcTemplate = collectJdbcTemplate;
         this.retentionConfig = retentionConfig;
     }
 
     private static final DateTimeFormatter PARTITION_DATE_FORMAT = DateTimeFormatter.ofPattern("yyMMdd");
     private static final DateTimeFormatter PARTITION_MONTH_FORMAT = DateTimeFormatter.ofPattern("yyyy_MM");
 
-    // 일별 파티션 테이블 목록 (queryDB만 관리)
-    private static final List<String> DAILY_PARTITION_TABLES = List.of(
+    // CollectDB 일별 파티션 테이블 목록
+    private static final List<String> COLLECT_DAILY_PARTITION_TABLES = List.of(
+            "sig_test"
+    );
+
+    // QueryDB 일별 파티션 테이블 목록
+    private static final List<String> QUERY_DAILY_PARTITION_TABLES = List.of(
             "t_vessel_tracks_5min",
             "t_grid_vessel_tracks",
             "t_grid_tracks_summary",
@@ -52,12 +60,11 @@ public class PartitionManager {
     // 월별 파티션 테이블 목록
     private static final List<String> MONTHLY_PARTITION_TABLES = List.of(
             "t_vessel_tracks_hourly",
-            "t_grid_vessel_tracks_hourly",
+            "t_vessel_tracks_daily",
             "t_grid_tracks_summary_hourly",
             "t_grid_tracks_summary_daily",
             "t_area_tracks_summary_hourly",
             "t_area_tracks_summary_daily",
-            "t_vessel_tracks_daily",
             "t_abnormal_tracks"
     );
 
@@ -68,7 +75,10 @@ public class PartitionManager {
     public void initialize() {
         log.info("========== PartitionManager Initialization ==========");
 
-        // DataSource 정보 로깅 (queryDB만)
+        // DataSource 정보 로깅
+        log.info("=== Collect DataSource Info ===");
+        DataSourceLogger.logJdbcTemplateInfo("PartitionManager-Collect", collectJdbcTemplate);
+
         log.info("=== Query DataSource Info ===");
         DataSourceLogger.logJdbcTemplateInfo("PartitionManager-Query", queryJdbcTemplate);
 
@@ -113,7 +123,7 @@ public class PartitionManager {
         try {
             LocalDate today = LocalDate.now();
 
-            // 1. 일별 파티션 생성
+            // 1. 일별 파티션 생성 (CollectDB + QueryDB)
             createDailyPartitions(today, retentionConfig.getFutureDays());
 
             // 2. 월별 파티션 생성 (매월 1일에 다음달 파티션 생성)
@@ -138,13 +148,20 @@ public class PartitionManager {
     }
 
     /**
-     * 현재 존재하는 테이블 확인 (queryDB만)
+     * 현재 존재하는 테이블 확인
      */
     private void checkExistingTables() {
-        log.info("Checking existing tables in queryDB...");
+        log.info("Checking existing tables...");
 
-        // 일별 파티션 테이블 확인
-        for (String table : DAILY_PARTITION_TABLES) {
+        // CollectDB 일별 파티션 테이블 확인
+        log.info("--- CollectDB Tables ---");
+        for (String table : COLLECT_DAILY_PARTITION_TABLES) {
+            checkTableExists("signal", table, collectJdbcTemplate, "CollectDB");
+        }
+
+        // QueryDB 일별 파티션 테이블 확인
+        log.info("--- QueryDB Tables ---");
+        for (String table : QUERY_DAILY_PARTITION_TABLES) {
             checkTableExists("signal", table, queryJdbcTemplate, "QueryDB");
         }
 
@@ -166,7 +183,7 @@ public class PartitionManager {
     }
 
     /**
-     * 일별 파티션 생성 (queryDB만)
+     * 일별 파티션 생성 (CollectDB + QueryDB)
      */
     private void createDailyPartitions(LocalDate startDate, int days) {
         log.info("Creating daily partitions for {} days starting from {}", days, startDate);
@@ -176,8 +193,14 @@ public class PartitionManager {
         IntStream.range(0, days).forEach(offset -> {
             LocalDate targetDate = startDate.plusDays(offset);
 
-            for (String table : DAILY_PARTITION_TABLES) {
-                tasks.add(new PartitionTask("signal", table, targetDate, queryJdbcTemplate, "daily"));
+            // CollectDB 파티션
+            for (String table : COLLECT_DAILY_PARTITION_TABLES) {
+                tasks.add(new PartitionTask("signal", table, targetDate, collectJdbcTemplate, "daily", "CollectDB"));
+            }
+
+            // QueryDB 파티션
+            for (String table : QUERY_DAILY_PARTITION_TABLES) {
+                tasks.add(new PartitionTask("signal", table, targetDate, queryJdbcTemplate, "daily", "QueryDB"));
             }
         });
 
@@ -186,7 +209,7 @@ public class PartitionManager {
     }
 
     /**
-     * 월별 파티션 생성
+     * 월별 파티션 생성 (QueryDB만)
      */
     private void createMonthlyPartitions(LocalDate targetMonth) {
         log.info("Creating monthly partitions for {}", targetMonth.format(DateTimeFormatter.ofPattern("yyyy-MM")));
@@ -194,7 +217,7 @@ public class PartitionManager {
         List<PartitionTask> tasks = new ArrayList<>();
 
         for (String table : MONTHLY_PARTITION_TABLES) {
-            tasks.add(new PartitionTask("signal", table, targetMonth, queryJdbcTemplate, "monthly"));
+            tasks.add(new PartitionTask("signal", table, targetMonth, queryJdbcTemplate, "monthly", "QueryDB"));
         }
 
         // 병렬 처리
@@ -235,19 +258,19 @@ public class PartitionManager {
         try {
             // 파티션 존재 확인
             if (partitionExists(task.schema, partitionName, task.jdbcTemplate)) {
-                log.debug("[QueryDB] Partition already exists: {}.{}", task.schema, partitionName);
+                log.debug("[{}] Partition already exists: {}.{}", task.dbType, task.schema, partitionName);
                 return;
             }
 
             // 파티션 생성
             task.jdbcTemplate.execute(createSql);
-            log.info("[QueryDB] Created partition: {}.{}", task.schema, partitionName);
+            log.info("[{}] Created partition: {}.{}", task.dbType, task.schema, partitionName);
 
             // 파티션별 인덱스 생성
             createPartitionIndexes(task.schema, partitionName, task.baseTable, task.jdbcTemplate);
 
         } catch (Exception e) {
-            log.error("[QueryDB] Failed to create partition: {}.{}", task.schema, partitionName, e);
+            log.error("[{}] Failed to create partition: {}.{}", task.dbType, task.schema, partitionName, e);
         }
     }
 
@@ -384,13 +407,6 @@ public class PartitionManager {
                     ));
                 }
             }
-            // 해구별 hourly 테이블 진입 이력 인덱스
-            if (baseTable.equals("t_grid_vessel_tracks_hourly")) {
-                indexSqls.add(String.format(
-                        "CREATE INDEX CONCURRENTLY IF NOT EXISTS %s_vessel_time_idx ON %s.%s (sig_src_cd, target_id, time_bucket DESC)",
-                        partitionName, schema, partitionName
-                ));
-            }
         }
         // 일별 궤적 테이블
         else if (baseTable.contains("daily")) {
@@ -459,38 +475,54 @@ public class PartitionManager {
         log.info("Cleanup Date: {}", today);
 
         try {
-            // 일별 파티션 테이블 정리
-            log.info("--- Daily Partition Tables ---");
-            for (String tableName : DAILY_PARTITION_TABLES) {
+            // CollectDB 일별 파티션 테이블 정리
+            log.info("--- CollectDB Daily Partition Tables ---");
+            for (String tableName : COLLECT_DAILY_PARTITION_TABLES) {
                 int retentionDays = retentionConfig.getRetentionDays(tableName);
 
                 if (retentionDays <= 0) {
-                    log.info("[{}] Unlimited retention (days={}). Skipping cleanup.", tableName, retentionDays);
+                    log.info("[CollectDB:{}] Unlimited retention (days={}). Skipping cleanup.", tableName, retentionDays);
                     continue;
                 }
 
                 LocalDate cutoffDate = today.minusDays(retentionDays);
-                log.info("[{}] Retention: {} days, Cutoff: {}", tableName, retentionDays, cutoffDate);
+                log.info("[CollectDB:{}] Retention: {} days, Cutoff: {}", tableName, retentionDays, cutoffDate);
 
-                dropPartitionsForTable(tableName, cutoffDate);
+                dropPartitionsForTable(tableName, cutoffDate, collectJdbcTemplate, "CollectDB");
             }
 
-            // 월별 파티션 테이블 정리
+            // QueryDB 일별 파티션 테이블 정리
+            log.info("--- QueryDB Daily Partition Tables ---");
+            for (String tableName : QUERY_DAILY_PARTITION_TABLES) {
+                int retentionDays = retentionConfig.getRetentionDays(tableName);
+
+                if (retentionDays <= 0) {
+                    log.info("[QueryDB:{}] Unlimited retention (days={}). Skipping cleanup.", tableName, retentionDays);
+                    continue;
+                }
+
+                LocalDate cutoffDate = today.minusDays(retentionDays);
+                log.info("[QueryDB:{}] Retention: {} days, Cutoff: {}", tableName, retentionDays, cutoffDate);
+
+                dropPartitionsForTable(tableName, cutoffDate, queryJdbcTemplate, "QueryDB");
+            }
+
+            // QueryDB 월별 파티션 테이블 정리
             log.info("");
-            log.info("--- Monthly Partition Tables ---");
+            log.info("--- QueryDB Monthly Partition Tables ---");
             for (String tableName : MONTHLY_PARTITION_TABLES) {
                 int retentionMonths = retentionConfig.getRetentionMonths(tableName);
 
                 if (retentionMonths <= 0) {
-                    log.info("[{}] Unlimited retention (months={}). Skipping cleanup.", tableName, retentionMonths);
+                    log.info("[QueryDB:{}] Unlimited retention (months={}). Skipping cleanup.", tableName, retentionMonths);
                     continue;
                 }
 
                 // 월 단위 계산: N개월 전의 1일
                 LocalDate cutoffDate = today.minusMonths(retentionMonths).withDayOfMonth(1);
-                log.info("[{}] Retention: {} months, Cutoff: {}", tableName, retentionMonths, cutoffDate);
+                log.info("[QueryDB:{}] Retention: {} months, Cutoff: {}", tableName, retentionMonths, cutoffDate);
 
-                dropPartitionsForTable(tableName, cutoffDate);
+                dropPartitionsForTable(tableName, cutoffDate, queryJdbcTemplate, "QueryDB");
             }
 
             log.info("========== Partition Cleanup Completed ==========");
@@ -503,34 +535,60 @@ public class PartitionManager {
     /**
      * 개별 테이블의 파티션 삭제
      */
-    private void dropPartitionsForTable(String tableName, LocalDate cutoffDate) {
+    private void dropPartitionsForTable(String tableName, LocalDate cutoffDate, JdbcTemplate jdbcTemplate, String dbType) {
         int droppedCount = 0;
         int keptCount = 0;
+        int skippedCount = 0;
+
+        // 월별 파티션 테이블인지 확인
+        boolean isMonthlyTable = MONTHLY_PARTITION_TABLES.contains(tableName);
 
         try {
-            List<PartitionInfo> partitions = findPartitions("signal", tableName + "_%", queryJdbcTemplate);
+            List<PartitionInfo> partitions = findPartitions("signal", tableName + "_%", jdbcTemplate);
 
             for (PartitionInfo partition : partitions) {
                 if (partition.partitionDate == null) {
-                    log.warn("  [{}] Cannot determine partition date, skipping: {}",
-                            tableName, partition.tableName);
+                    log.warn("  [{}:{}] Cannot determine partition date, skipping: {}",
+                            dbType, tableName, partition.tableName);
+                    skippedCount++;
+                    continue;
+                }
+
+                // 파티션 패턴 검증: 일별 vs 월별
+                boolean isDailyPattern = partition.tableName.matches(".*_\\d{6}$");
+                boolean isMonthlyPattern = partition.tableName.matches(".*_\\d{4}_\\d{2}$");
+
+                // 일별 파티션 정리 시: 월별 파티션은 건너뛰기
+                if (!isMonthlyTable && !isDailyPattern) {
+                    log.debug("  [{}:{}] Skipping non-daily partition during daily cleanup: {}",
+                            dbType, tableName, partition.tableName);
+                    skippedCount++;
+                    continue;
+                }
+
+                // 월별 파티션 정리 시: 일별 파티션은 건너뛰기
+                if (isMonthlyTable && !isMonthlyPattern) {
+                    log.debug("  [{}:{}] Skipping non-monthly partition during monthly cleanup: {}",
+                            dbType, tableName, partition.tableName);
+                    skippedCount++;
                     continue;
                 }
 
                 if (partition.partitionDate.isBefore(cutoffDate)) {
-                    dropPartition(partition, queryJdbcTemplate);
+                    dropPartition(partition, jdbcTemplate);
                     droppedCount++;
-                    log.info("  [{}] Dropped: {} (date: {})",
-                            tableName, partition.tableName, partition.partitionDate);
+                    log.info("  [{}:{}] Dropped: {} (date: {})",
+                            dbType, tableName, partition.tableName, partition.partitionDate);
                 } else {
                     keptCount++;
                 }
             }
 
-            log.info("  [{}] Result: dropped={}, kept={}", tableName, droppedCount, keptCount);
+            log.info("  [{}:{}] Result: dropped={}, kept={}, skipped={}",
+                    dbType, tableName, droppedCount, keptCount, skippedCount);
 
         } catch (Exception e) {
-            log.error("  [{}] Failed to clean partitions: {}", tableName, e.getMessage(), e);
+            log.error("  [{}:{}] Failed to clean partitions: {}", dbType, tableName, e.getMessage(), e);
         }
     }
 
@@ -716,13 +774,15 @@ public class PartitionManager {
         LocalDate date;
         JdbcTemplate jdbcTemplate;
         String partitionType; // "daily" or "monthly"
+        String dbType; // "CollectDB" or "QueryDB"
 
-        PartitionTask(String schema, String baseTable, LocalDate date, JdbcTemplate jdbcTemplate, String partitionType) {
+        PartitionTask(String schema, String baseTable, LocalDate date, JdbcTemplate jdbcTemplate, String partitionType, String dbType) {
             this.schema = schema;
             this.baseTable = baseTable;
             this.date = date;
             this.jdbcTemplate = jdbcTemplate;
             this.partitionType = partitionType;
+            this.dbType = dbType;
         }
     }
 
diff --git a/src/main/java/gc/mda/signal_batch/global/util/ShipKindCodeConverter.java b/src/main/java/gc/mda/signal_batch/global/util/ShipKindCodeConverter.java
index 6b8d13b..44b0685 100644
--- a/src/main/java/gc/mda/signal_batch/global/util/ShipKindCodeConverter.java
+++ b/src/main/java/gc/mda/signal_batch/global/util/ShipKindCodeConverter.java
@@ -124,9 +124,85 @@ public class ShipKindCodeConverter {
         return SHIP_KIND_MAP.getOrDefault(key, "000027"); // 기본값: 기타
     }
     
+    /**
+     * sig_src_cd, shipType, shipName, targetId를 조합하여 shipKindCode를 반환
+     * 선박명 패턴 매칭을 통해 어망/부이(000028) 우선 판별
+     *
+     * @param sigSrcCd 신호 소스 코드 (ex: 000001, 000004, ...)
+     * @param shipType 선박 타입 (ex: 30, B005, ...)
+     * @param shipName 선박명 (ex: "부이-123", "어망.설치선", ...)
+     * @param targetId 타겟 ID (MMSI 등, ex: "440123456", "123456789")
+     * @return shipKindCode (ex: 000020, 000028, ...) 매칭되지 않으면 000027(기타)
+     */
+    public static String getShipKindCodeWithNamePattern(String sigSrcCd, String shipType, String shipName, String targetId) {
+        // 1. 어망/부이 패턴 체크 조건:
+        //    - AIS(000001) 또는 VTS-AIS(000004)
+        //    - 한국 국적 선박 제외 (target_id가 440 또는 441로 시작하지 않음)
+        //    - 선박명에 어망/부이 패턴 포함
+        if (isAisOrVtsAis(sigSrcCd) && !isKoreanVessel(targetId) && containsBuoyPattern(shipName)) {
+            return "000028"; // 어망/부이
+        }
+
+        // 2. 기존 로직 수행
+        return getShipKindCode(sigSrcCd, shipType);
+    }
+
+    /**
+     * 하위 호환성을 위한 오버로드 메서드 (targetId 없이 호출 시)
+     * @deprecated targetId를 포함한 메서드 사용 권장
+     */
+    @Deprecated
+    public static String getShipKindCodeWithNamePattern(String sigSrcCd, String shipType, String shipName) {
+        return getShipKindCodeWithNamePattern(sigSrcCd, shipType, shipName, null);
+    }
+
+    /**
+     * AIS(000001) 또는 VTS-AIS(000004) 신호원인지 확인
+     */
+    private static boolean isAisOrVtsAis(String sigSrcCd) {
+        return "000001".equals(sigSrcCd) || "000004".equals(sigSrcCd);
+    }
+
+    /**
+     * 한국 국적 선박인지 확인 (MMSI가 440 또는 441로 시작)
+     * 한국 국적 선박은 선박명에 특수문자가 포함되어도 어망/부이가 아님
+     */
+    private static boolean isKoreanVessel(String targetId) {
+        if (targetId == null || targetId.length() < 3) {
+            return false;
+        }
+        String prefix = targetId.substring(0, 3);
+        return "440".equals(prefix) || "441".equals(prefix);
+    }
+
+    /**
+     * 선박명에 어망/부이 패턴이 포함되어 있는지 확인
+     *
+     * 패턴 규칙:
+     * - '%' 포함 시 → 어망/부이
+     * - '-'와 '.'가 동시에 포함 시 → 어망/부이 (예: "ABC-5.5", "ABC.5-5")
+     * - '-'만 또는 '.'만 포함 시 → 일반 선박 (예: "ABC NO.5", "S-92")
+     */
+    private static boolean containsBuoyPattern(String shipName) {
+        if (shipName == null || shipName.isEmpty()) {
+            return false;
+        }
+
+        // '%' 포함 시 어망/부이
+        if (shipName.contains("%")) {
+            return true;
+        }
+
+        // '-'와 '.'가 동시에 포함될 때만 어망/부이
+        boolean hasDash = shipName.contains("-");
+        boolean hasDot = shipName.contains(".");
+
+        return hasDash && hasDot;
+    }
+
     /**
      * 선박 종류 명칭 반환
-     * 
+     *
      * @param shipKindCode 선박 종류 코드
      * @return 선박 종류 명칭
      */
@@ -139,6 +215,7 @@ public class ShipKindCodeConverter {
             case "000024": return "유조선";
             case "000025": return "관공선";
             case "000027": return "기타";
+            case "000028": return "어망/부이";
             default: return "기타";
         }
     }
diff --git a/src/main/java/gc/mda/signal_batch/global/util/TrackConverter.java b/src/main/java/gc/mda/signal_batch/global/util/TrackConverter.java
new file mode 100644
index 0000000..2486205
--- /dev/null
+++ b/src/main/java/gc/mda/signal_batch/global/util/TrackConverter.java
@@ -0,0 +1,231 @@
+package gc.mda.signal_batch.global.util;
+
+import gc.mda.signal_batch.domain.vessel.dto.CompactVesselTrack;
+import gc.mda.signal_batch.domain.vessel.dto.TrackResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.LineString;
+import org.locationtech.jts.io.ParseException;
+import org.locationtech.jts.io.WKTReader;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * TrackResponse (WKT 기반) → CompactVesselTrack (배열 기반) 변환 유틸리티
+ * WebSocket API와 REST API의 응답 구조 통일을 위해 사용
+ */
+@Slf4j
+public class TrackConverter {
+
+    private static final WKTReader wktReader = new WKTReader();
+
+    /**
+     * 선박별로 분리된 TrackResponse 리스트를 CompactVesselTrack 리스트로 변환
+     * - 동일 선박의 여러 세그먼트를 병합
+     * - LineStringM을 geometry/timestamps/speeds 배열로 파싱
+     *
+     * @param trackResponses TrackResponse 리스트 (세그먼트별 분리)
+     * @param vesselInfoProvider 선박 정보 조회 함수 (sigSrcCd, targetId → VesselInfo)
+     * @return CompactVesselTrack 리스트 (선박별 병합)
+     */
+    public static List<CompactVesselTrack> convert(
+            List<TrackResponse> trackResponses,
+            VesselInfoProvider vesselInfoProvider) {
+
+        if (trackResponses == null || trackResponses.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        // 1. 선박별로 그룹핑
+        Map<String, List<TrackResponse>> byVessel = trackResponses.stream()
+                .collect(Collectors.groupingBy(
+                        t -> t.getSigSrcCd() + "_" + t.getTargetId(),
+                        LinkedHashMap::new,
+                        Collectors.toList()
+                ));
+
+        // 2. 각 선박별로 세그먼트 병합 및 변환
+        List<CompactVesselTrack> result = new ArrayList<>();
+
+        for (Map.Entry<String, List<TrackResponse>> entry : byVessel.entrySet()) {
+            String vesselId = entry.getKey();
+            List<TrackResponse> segments = entry.getValue();
+
+            CompactVesselTrack compactTrack = mergeSegments(vesselId, segments, vesselInfoProvider);
+            if (compactTrack != null && compactTrack.getPointCount() > 0) {
+                result.add(compactTrack);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * 단일 선박의 여러 세그먼트를 하나의 CompactVesselTrack으로 병합
+     */
+    private static CompactVesselTrack mergeSegments(
+            String vesselId,
+            List<TrackResponse> segments,
+            VesselInfoProvider vesselInfoProvider) {
+
+        if (segments == null || segments.isEmpty()) {
+            return null;
+        }
+
+        // 시간순 정렬
+        segments.sort(Comparator.comparing(TrackResponse::getTimeBucket));
+
+        String sigSrcCd = segments.get(0).getSigSrcCd();
+        String targetId = segments.get(0).getTargetId();
+
+        // 누적 데이터
+        List<double[]> allGeometry = new ArrayList<>();
+        List<String> allTimestamps = new ArrayList<>();
+        List<Double> allSpeeds = new ArrayList<>();
+        double totalDistance = 0;
+        double maxSpeed = 0;
+
+        Coordinate prevCoord = null;
+        long prevTimeMillis = 0;
+
+        for (TrackResponse segment : segments) {
+            String trackGeom = segment.getTrackGeom();
+            if (trackGeom == null || trackGeom.isEmpty() || "LINESTRING EMPTY".equals(trackGeom)) {
+                continue;
+            }
+
+            try {
+                LineString lineString = (LineString) wktReader.read(trackGeom);
+
+                if (lineString.getNumPoints() == 0) {
+                    continue;
+                }
+
+                for (int i = 0; i < lineString.getNumPoints(); i++) {
+                    Coordinate coord = lineString.getCoordinateN(i);
+                    allGeometry.add(new double[]{coord.x, coord.y});
+
+                    // M값 (Unix timestamp 초 단위)
+                    long unixTimestamp = (long) coord.getM();
+                    allTimestamps.add(String.valueOf(unixTimestamp));
+
+                    // 속도 계산
+                    double speed = 0.0;
+                    long currentTimeMillis = unixTimestamp * 1000;
+
+                    if (prevCoord != null && prevTimeMillis > 0) {
+                        double distance = calculateDistanceNm(prevCoord.y, prevCoord.x, coord.y, coord.x);
+                        long timeDiff = currentTimeMillis - prevTimeMillis;
+                        if (timeDiff > 0) {
+                            speed = distance / (timeDiff / 3600000.0); // knots
+                        }
+                    }
+                    allSpeeds.add(speed);
+
+                    prevCoord = coord;
+                    prevTimeMillis = currentTimeMillis;
+                }
+
+                // 통계 누적
+                if (segment.getDistanceNm() != null) {
+                    totalDistance += segment.getDistanceNm().doubleValue();
+                }
+                if (segment.getMaxSpeed() != null) {
+                    maxSpeed = Math.max(maxSpeed, segment.getMaxSpeed().doubleValue());
+                }
+
+            } catch (ParseException e) {
+                log.warn("Failed to parse LineStringM for vessel {}: {}", vesselId, e.getMessage());
+            }
+        }
+
+        if (allGeometry.isEmpty()) {
+            return null;
+        }
+
+        // 선박 정보 조회
+        VesselInfo vesselInfo = vesselInfoProvider != null
+                ? vesselInfoProvider.getVesselInfo(sigSrcCd, targetId)
+                : new VesselInfo("-", "-");
+
+        // 국적 코드 계산
+        String nationalCode = NationalCodeUtil.calculateNationalCode(sigSrcCd, targetId);
+
+        // shipKindCode 계산
+        String shipKindCode = ShipKindCodeConverter.getShipKindCodeWithNamePattern(
+                sigSrcCd, vesselInfo.getShipType(), vesselInfo.getShipName(), targetId);
+
+        // 평균 속도 계산
+        double avgSpeed = allSpeeds.stream()
+                .filter(s -> s > 0)
+                .mapToDouble(Double::doubleValue)
+                .average()
+                .orElse(0.0);
+
+        return CompactVesselTrack.builder()
+                .vesselId(vesselId)
+                .sigSrcCd(sigSrcCd)
+                .targetId(targetId)
+                .nationalCode(nationalCode)
+                .geometry(allGeometry)
+                .timestamps(allTimestamps)
+                .speeds(allSpeeds)
+                .totalDistance(totalDistance)
+                .avgSpeed(Math.round(avgSpeed * 100.0) / 100.0)
+                .maxSpeed(Math.round(maxSpeed * 100.0) / 100.0)
+                .pointCount(allGeometry.size())
+                .shipName(vesselInfo.getShipName())
+                .shipType(vesselInfo.getShipType())
+                .shipKindCode(shipKindCode)
+                .build();
+    }
+
+    /**
+     * 두 좌표 사이의 거리 계산 (Haversine 공식, 해리)
+     */
+    private static double calculateDistanceNm(double lat1, double lon1, double lat2, double lon2) {
+        double lat1Rad = Math.toRadians(lat1);
+        double lat2Rad = Math.toRadians(lat2);
+        double deltaLat = lat2Rad - lat1Rad;
+        double deltaLon = Math.toRadians(lon2 - lon1);
+
+        double a = Math.sin(deltaLat / 2) * Math.sin(deltaLat / 2) +
+                Math.cos(lat1Rad) * Math.cos(lat2Rad) *
+                        Math.sin(deltaLon / 2) * Math.sin(deltaLon / 2);
+        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+        // 지구 반지름 (nm)
+        double R = 3440.065;
+        return R * c;
+    }
+
+    /**
+     * 선박 정보 조회 인터페이스
+     */
+    @FunctionalInterface
+    public interface VesselInfoProvider {
+        VesselInfo getVesselInfo(String sigSrcCd, String targetId);
+    }
+
+    /**
+     * 선박 정보 DTO
+     */
+    public static class VesselInfo {
+        private final String shipName;
+        private final String shipType;
+
+        public VesselInfo(String shipName, String shipType) {
+            this.shipName = shipName != null ? shipName : "-";
+            this.shipType = shipType != null ? shipType : "-";
+        }
+
+        public String getShipName() {
+            return shipName;
+        }
+
+        public String getShipType() {
+            return shipType;
+        }
+    }
+}
diff --git a/src/main/java/gc/mda/signal_batch/global/util/VesselTrackDataJobListener.java b/src/main/java/gc/mda/signal_batch/global/util/VesselTrackDataJobListener.java
index 0108035..0764353 100644
--- a/src/main/java/gc/mda/signal_batch/global/util/VesselTrackDataJobListener.java
+++ b/src/main/java/gc/mda/signal_batch/global/util/VesselTrackDataJobListener.java
@@ -2,6 +2,7 @@ package gc.mda.signal_batch.global.util;
 
 import gc.mda.signal_batch.domain.vessel.model.VesselData;
 import gc.mda.signal_batch.domain.gis.cache.AreaBoundaryCache;
+import gc.mda.signal_batch.domain.vessel.service.VesselPreviousBucketCache;
 
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -28,16 +29,21 @@ public class VesselTrackDataJobListener implements JobExecutionListener {
     
     private final JdbcTemplate collectJdbcTemplate;
     private final VesselTrackDataHolder vesselTrackDataHolder;
-    private final AreaBoundaryCache areaBoundaryCache;  // 추가
-    
+    private final AreaBoundaryCache areaBoundaryCache;
+    private final VesselPreviousBucketCache previousBucketCache;
+
     @Value("${vessel.batch.fetch-size:50000}")
     private int fetchSize;
-    
+
     @BeforeJob
     public void beforeJob(JobExecution jobExecution) {
         // Area/Haegu 경계 캐시 갱신
         areaBoundaryCache.refresh();
         log.info("Refreshed area boundary cache");
+
+        // 이전 버킷 캐시 Fallback 플래그 리셋 (새 Job 실행 시 1회만 DB 조회)
+        previousBucketCache.resetFallbackFlag();
+        log.info("Reset previous bucket cache fallback flag");
         
         LocalDateTime startTime = LocalDateTime.parse(
                 jobExecution.getJobParameters().getString("startTime"));
@@ -111,6 +117,10 @@ public class VesselTrackDataJobListener implements JobExecutionListener {
     
     @Override
     public void afterJob(JobExecution jobExecution) {
+        // DB 조회 통계 출력
+        previousBucketCache.logJobStatistics();
+
+        // 데이터 정리
         vesselTrackDataHolder.clear();
         log.debug("Cleared vessel track data after job completion");
     }
diff --git a/src/main/java/gc/mda/signal_batch/global/websocket/service/ChunkedTrackStreamingService.java b/src/main/java/gc/mda/signal_batch/global/websocket/service/ChunkedTrackStreamingService.java
index 2bbb9f3..fd759f7 100644
--- a/src/main/java/gc/mda/signal_batch/global/websocket/service/ChunkedTrackStreamingService.java
+++ b/src/main/java/gc/mda/signal_batch/global/websocket/service/ChunkedTrackStreamingService.java
@@ -535,8 +535,9 @@ public class ChunkedTrackStreamingService {
                                 accumulator.shipName = vesselInfo.shipName;
                                 accumulator.shipType = vesselInfo.shipType;
 
-                                // shipKindCode 계산
-                                accumulator.shipKindCode = ShipKindCodeConverter.getShipKindCode(sigSrcCd, vesselInfo.shipType);
+                                // shipKindCode 계산 (선박명 패턴 매칭 포함 - 어망/부이 판별)
+                                accumulator.shipKindCode = ShipKindCodeConverter.getShipKindCodeWithNamePattern(
+                                    sigSrcCd, vesselInfo.shipType, vesselInfo.shipName, targetId);
 
                                 // 테스트용 로그 - 처음 10개 선박만
 //                                if (vesselCount <= 10) {
@@ -568,8 +569,9 @@ public class ChunkedTrackStreamingService {
 
 //                log.info("[{}] Range [{} - {}] = {} minutes, {} buckets expected",
 //                    tableName, range.getStart(), range.getEnd(), rangeMinutes, expectedBuckets);
-//                log.info("[{}] Processed {} tracks for {} unique vessels (avg {:.1f} tracks/vessel)",
-//                    tableName, trackCount, vesselCount, vesselCount > 0 ? (double)trackCount/vesselCount : 0);
+//                log.info("[{}] Processed {} tracks for {} unique vessels (avg {} tracks/vessel)",
+//                    tableName, trackCount, vesselCount,
+//                    vesselCount > 0 ? String.format("%.1f", (double)trackCount/vesselCount) : "0.0");
 //                log.debug("[{}] Vessel count in this chunk: {} (cumulative in vesselMap: {})",
 //                    tableName, vesselCount, vesselMap.size());
             }
@@ -849,8 +851,9 @@ public class ChunkedTrackStreamingService {
                                         accumulator.shipName = vesselInfo.shipName;
                                         accumulator.shipType = vesselInfo.shipType;
 
-                                        // shipKindCode 계산
-                                        accumulator.shipKindCode = ShipKindCodeConverter.getShipKindCode(track.getSigSrcCd(), vesselInfo.shipType);
+                                        // shipKindCode 계산 (선박명 패턴 매칭 포함 - 어망/부이 판별)
+                                        accumulator.shipKindCode = ShipKindCodeConverter.getShipKindCodeWithNamePattern(
+                                            track.getSigSrcCd(), vesselInfo.shipType, vesselInfo.shipName, track.getTargetId());
 
                                         mergedMap.put(vesselId, accumulator);
                                     }
@@ -1761,8 +1764,9 @@ public class ChunkedTrackStreamingService {
                                     acc.targetId = finalTargetId;
                                     acc.shipName = info.shipName;
                                     acc.shipType = info.shipType;
-                                    // shipKindCode 계산 추가
-                                    acc.shipKindCode = ShipKindCodeConverter.getShipKindCode(finalSigSrcCd, info.shipType);
+                                    // shipKindCode 계산 (선박명 패턴 매칭 포함 - 어망/부이 판별)
+                                    acc.shipKindCode = ShipKindCodeConverter.getShipKindCodeWithNamePattern(
+                                        finalSigSrcCd, info.shipType, info.shipName, finalTargetId);
                                     return acc;
                                 });
 
@@ -2406,7 +2410,9 @@ public class ChunkedTrackStreamingService {
                                     acc.targetId = finalTargetId;
                                     acc.shipName = info.shipName;
                                     acc.shipType = info.shipType;
-                                    acc.shipKindCode = ShipKindCodeConverter.getShipKindCode(finalSigSrcCd, info.shipType);
+                                    // shipKindCode 계산 (선박명 패턴 매칭 포함 - 어망/부이 판별)
+                                    acc.shipKindCode = ShipKindCodeConverter.getShipKindCodeWithNamePattern(
+                                        finalSigSrcCd, info.shipType, info.shipName, finalTargetId);
                                     return acc;
                                 });
 
diff --git a/src/main/java/gc/mda/signal_batch/monitoring/controller/BatchAdminController.java b/src/main/java/gc/mda/signal_batch/monitoring/controller/BatchAdminController.java
index 6d6e5ea..093a605 100644
--- a/src/main/java/gc/mda/signal_batch/monitoring/controller/BatchAdminController.java
+++ b/src/main/java/gc/mda/signal_batch/monitoring/controller/BatchAdminController.java
@@ -1,6 +1,9 @@
 package gc.mda.signal_batch.monitoring.controller;
 
 import gc.mda.signal_batch.monitoring.service.BatchMetadataCleanupService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.batch.core.*;
@@ -28,6 +31,7 @@ import java.util.stream.Collectors;
 @RequestMapping("/admin/batch")
 @ConditionalOnProperty(name = "vessel.batch.scheduler.enabled", havingValue = "true", matchIfMissing = true)
 @RequiredArgsConstructor
+@Tag(name = "배치 관리 API", description = "Spring Batch Job 실행, 중지, 재시작 및 통계 조회 API")
 public class BatchAdminController {
 
     @Autowired
@@ -57,10 +61,11 @@ public class BatchAdminController {
      * Job 실행
      */
     @PostMapping("/job/run")
+    @Operation(summary = "배치 Job 실행", description = "지정된 배치 Job을 실행합니다. vesselAggregationJob, vesselTrackAggregationJob, dailyAggregationJob 지원")
     public ResponseEntity<Map<String, Object>> runJob(
-            @RequestParam(required = false) String jobName,
-            @RequestParam(required = false) String startTime,
-            @RequestParam(required = false) String endTime) {
+            @Parameter(description = "Job 이름 (기본: vesselAggregationJob)") @RequestParam(required = false) String jobName,
+            @Parameter(description = "시작 시간 (형식: yyyy-MM-ddTHH:mm:ss)") @RequestParam(required = false) String startTime,
+            @Parameter(description = "종료 시간 (형식: yyyy-MM-ddTHH:mm:ss)") @RequestParam(required = false) String endTime) {
 
         try {
             Job job;
@@ -113,7 +118,9 @@ public class BatchAdminController {
      * Job 중지
      */
     @PostMapping("/job/stop/{executionId}")
-    public ResponseEntity<Map<String, Object>> stopJob(@PathVariable Long executionId) {
+    @Operation(summary = "실행 중인 Job 중지", description = "실행 중인 배치 Job을 중지합니다")
+    public ResponseEntity<Map<String, Object>> stopJob(
+            @Parameter(description = "Job 실행 ID") @PathVariable Long executionId) {
         try {
             boolean stopped = jobOperator.stop(executionId);
 
@@ -133,7 +140,9 @@ public class BatchAdminController {
      * Job 재시작
      */
     @PostMapping("/job/restart/{executionId}")
-    public ResponseEntity<Map<String, Object>> restartJob(@PathVariable Long executionId) {
+    @Operation(summary = "실패한 Job 재시작", description = "실패한 배치 Job을 재시작합니다")
+    public ResponseEntity<Map<String, Object>> restartJob(
+            @Parameter(description = "Job 실행 ID") @PathVariable Long executionId) {
         try {
             Long newExecutionId = jobOperator.restart(executionId);
 
@@ -153,7 +162,9 @@ public class BatchAdminController {
      * 실패한 Job을 ABANDONED 상태로 변경 (재시도 방지)
      */
     @PostMapping("/job/abandon/{executionId}")
-    public ResponseEntity<Map<String, Object>> abandonJob(@PathVariable Long executionId) {
+    @Operation(summary = "Job ABANDONED 처리", description = "실패한 Job을 ABANDONED 상태로 변경하여 재시도를 방지합니다")
+    public ResponseEntity<Map<String, Object>> abandonJob(
+            @Parameter(description = "Job 실행 ID") @PathVariable Long executionId) {
         try {
             JobExecution execution = jobExplorer.getJobExecution(executionId);
 
@@ -214,6 +225,7 @@ public class BatchAdminController {
      * 모든 실패한 Job을 ABANDONED로 변경
      */
     @PostMapping("/job/abandon-all-failed")
+    @Operation(summary = "모든 실패한 Job ABANDONED 처리", description = "모든 실패 상태의 Job을 일괄로 ABANDONED 상태로 변경합니다")
     public ResponseEntity<Map<String, Object>> abandonAllFailedJobs() {
         try {
             int abandonedCount = 0;
@@ -272,6 +284,7 @@ public class BatchAdminController {
      * 실행 중인 Job 목록
      */
     @GetMapping("/job/running")
+    @Operation(summary = "실행 중인 Job 목록", description = "현재 실행 중인 모든 배치 Job 목록을 조회합니다")
     public ResponseEntity<List<Map<String, Object>>> getRunningJobs() {
         try {
             List<Map<String, Object>> runningJobs = new ArrayList<>();
@@ -315,9 +328,10 @@ public class BatchAdminController {
      * Job 실행 이력
      */
     @GetMapping("/job/history")
+    @Operation(summary = "Job 실행 이력 조회", description = "배치 Job의 실행 이력을 조회합니다")
     public ResponseEntity<List<Map<String, Object>>> getJobHistory(
-            @RequestParam(required = false) String jobName,
-            @RequestParam(defaultValue = "50") int limit) {
+            @Parameter(description = "Job 이름 (미지정시 전체)") @RequestParam(required = false) String jobName,
+            @Parameter(description = "조회 개수") @RequestParam(defaultValue = "50") int limit) {
 
         try {
             List<Map<String, Object>> history = new ArrayList<>();
@@ -452,8 +466,9 @@ public class BatchAdminController {
      * 실패한 Job 목록
      */
     @GetMapping("/job/failed")
+    @Operation(summary = "실패한 Job 목록", description = "지정된 시간 내의 실패한 Job 목록을 조회합니다")
     public ResponseEntity<List<Map<String, Object>>> getFailedJobs(
-            @RequestParam(defaultValue = "24") int hoursBack) {
+            @Parameter(description = "조회 기간 (시간)") @RequestParam(defaultValue = "24") int hoursBack) {
 
         try {
             LocalDateTime since = LocalDateTime.now().minusHours(hoursBack);
@@ -523,8 +538,9 @@ public class BatchAdminController {
      * 배치 통계
      */
     @GetMapping("/statistics")
+    @Operation(summary = "배치 통계 조회", description = "지정된 기간의 배치 실행 통계를 조회합니다")
     public ResponseEntity<Map<String, Object>> getBatchStatistics(
-            @RequestParam(defaultValue = "7") int days) {
+            @Parameter(description = "조회 기간 (일)") @RequestParam(defaultValue = "7") int days) {
 
         try {
             LocalDateTime since = LocalDateTime.now().minusDays(days);
@@ -639,6 +655,7 @@ public class BatchAdminController {
      * 일별 처리 통계 (Dashboard 차트용)
      */
     @GetMapping("/daily-stats")
+    @Operation(summary = "일별 처리 통계", description = "최근 7일간 일별 배치 처리 통계를 조회합니다 (대시보드 차트용)")
     public ResponseEntity<Map<String, Object>> getDailyStatistics() {
         try {
             Map<String, Object> result = new HashMap<>();
@@ -753,6 +770,7 @@ public class BatchAdminController {
      * 배치 메타데이터 정리 실행
      */
     @PostMapping("/cleanup")
+    @Operation(summary = "배치 메타데이터 정리", description = "오래된 배치 Job 메타데이터를 정리합니다")
     public ResponseEntity<Map<String, Object>> cleanupBatchMetadata() {
         try {
             log.info("Manual batch metadata cleanup requested");
@@ -806,6 +824,7 @@ public class BatchAdminController {
      * 손상된 ExecutionContext 데이터 정리 (패키지 변경으로 인한 역직렬화 오류)
      */
     @PostMapping("/cleanup-corrupted")
+    @Operation(summary = "손상된 ExecutionContext 정리", description = "패키지 변경으로 인한 역직렬화 오류가 발생한 ExecutionContext 데이터를 정리합니다")
     public ResponseEntity<Map<String, Object>> cleanupCorruptedExecutionContext() {
         try {
             log.info("Manual corrupted ExecutionContext cleanup requested");
@@ -833,6 +852,7 @@ public class BatchAdminController {
      * 배치 메타데이터 현재 상태 조회
      */
     @GetMapping("/metadata-status")
+    @Operation(summary = "배치 메타데이터 상태", description = "배치 메타데이터 테이블의 현재 상태를 조회합니다")
     public ResponseEntity<Map<String, Object>> getBatchMetadataStatus() {
         try {
             // 여기서는 간단하게 현재 테이블 상태만 조회
diff --git a/src/main/java/gc/mda/signal_batch/monitoring/controller/DataSourceDebugController.java b/src/main/java/gc/mda/signal_batch/monitoring/controller/DataSourceDebugController.java
index f45b83e..c2db053 100644
--- a/src/main/java/gc/mda/signal_batch/monitoring/controller/DataSourceDebugController.java
+++ b/src/main/java/gc/mda/signal_batch/monitoring/controller/DataSourceDebugController.java
@@ -1,6 +1,8 @@
 package gc.mda.signal_batch.monitoring.controller;
 
 import gc.mda.signal_batch.global.util.DataSourceLogger;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Qualifier;
@@ -23,6 +25,7 @@ import java.util.Map;
 @RequestMapping("/admin/debug")
 @RequiredArgsConstructor
 @ConditionalOnProperty(name = "vessel.batch.scheduler.enabled", havingValue = "true", matchIfMissing = true)
+@Tag(name = "DataSource 디버그 API", description = "DataSource 연결 상태 및 테이블 정보 확인 API")
 public class DataSourceDebugController {
 
     @Qualifier("collectDataSource")
@@ -41,6 +44,7 @@ public class DataSourceDebugController {
     private final JdbcTemplate queryJdbcTemplate;
 
     @GetMapping("/datasources")
+    @Operation(summary = "DataSource 정보 조회", description = "Collect, Query, Batch DataSource의 연결 정보, 스키마, 연결 테스트 결과를 조회합니다")
     public Map<String, Object> getDataSourceInfo() {
         Map<String, Object> result = new HashMap<>();
         
@@ -53,6 +57,7 @@ public class DataSourceDebugController {
     }
     
     @GetMapping("/check-tables")
+    @Operation(summary = "테이블 존재 여부 확인", description = "Collect DB와 Query DB의 주요 테이블 존재 여부 및 크기를 확인합니다")
     public Map<String, Object> checkTables() {
         Map<String, Object> result = new HashMap<>();
         
diff --git a/src/main/java/gc/mda/signal_batch/monitoring/controller/MetricsController.java b/src/main/java/gc/mda/signal_batch/monitoring/controller/MetricsController.java
index a3691b6..2feaeb0 100644
--- a/src/main/java/gc/mda/signal_batch/monitoring/controller/MetricsController.java
+++ b/src/main/java/gc/mda/signal_batch/monitoring/controller/MetricsController.java
@@ -1,5 +1,8 @@
 package gc.mda.signal_batch.monitoring.controller;
 
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.batch.core.JobExecution;
@@ -19,6 +22,7 @@ import java.util.*;
 @RequestMapping("/admin")
 @RequiredArgsConstructor
 @ConditionalOnProperty(name = "vessel.batch.scheduler.enabled", havingValue = "true", matchIfMissing = true)
+@Tag(name = "메트릭스 API", description = "시스템 메트릭, Job 통계, 대해구별 집계 및 데이터 정합성 검증 API")
 public class MetricsController {
 
     private final JobExplorer jobExplorer;
@@ -26,6 +30,7 @@ public class MetricsController {
 
 
     @GetMapping("/metrics/summary")
+    @Operation(summary = "시스템 메트릭 요약", description = "Job 통계, 메모리 사용량, 스레드 수, DB 연결 수 등 시스템 전반의 메트릭을 조회합니다")
     public Map<String, Object> getMetricsSummary() {
         Map<String, Object> summary = new HashMap<>();
 
@@ -80,7 +85,9 @@ public class MetricsController {
     }
 
     @GetMapping("/jobs/recent")
-    public List<Map<String, Object>> getRecentJobs(@RequestParam(defaultValue = "10") int count) {
+    @Operation(summary = "최근 Job 실행 이력", description = "vesselAggregationJob의 최근 실행 이력을 조회합니다. 상태, 시작/종료 시간, 처리 건수를 포함합니다")
+    public List<Map<String, Object>> getRecentJobs(
+            @Parameter(description = "조회할 Job 수 (기본: 10)") @RequestParam(defaultValue = "10") int count) {
         List<Map<String, Object>> jobs = new ArrayList<>();
 
         try {
@@ -124,6 +131,7 @@ public class MetricsController {
     }
 
     @GetMapping("/haegu/stats")
+    @Operation(summary = "대해구별 통계", description = "최근 15분 데이터 기준 대해구별 선박 수, 밀도 등 통계를 조회합니다. 대해구/소해구 레벨 데이터를 집계합니다")
     public List<Map<String, Object>> getHaeguStats() {
         List<Map<String, Object>> results = new ArrayList<>();
 
@@ -216,6 +224,7 @@ public class MetricsController {
      * 대해구 데이터 정합성 검증
      */
     @GetMapping("/haegu/validate")
+    @Operation(summary = "대해구 데이터 정합성 검증", description = "타일 레벨별 분포, 중복 데이터, 대해구-소해구 집계 정합성을 검증합니다")
     public Map<String, Object> validateHaeguData() {
         Map<String, Object> validation = new HashMap<>();
 
diff --git a/src/main/java/gc/mda/signal_batch/monitoring/controller/MigrationController.java b/src/main/java/gc/mda/signal_batch/monitoring/controller/MigrationController.java
index f0137e9..b45c80a 100644
--- a/src/main/java/gc/mda/signal_batch/monitoring/controller/MigrationController.java
+++ b/src/main/java/gc/mda/signal_batch/monitoring/controller/MigrationController.java
@@ -1,6 +1,9 @@
 package gc.mda.signal_batch.monitoring.controller;
 
 import gc.mda.signal_batch.migration.unix_timestamp.MissingDataFiller;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
@@ -20,12 +23,15 @@ import java.util.Map;
 @RequestMapping("/api/migration")
 @ConditionalOnProperty(name = "vessel.batch.scheduler.enabled", havingValue = "true", matchIfMissing = true)
 @RequiredArgsConstructor
+@Tag(name = "마이그레이션 API", description = "Unix timestamp 기반 항적 데이터 마이그레이션 및 누락 데이터 복구 API")
 public class MigrationController {
     
     private final MissingDataFiller missingDataFiller;
     
     @PostMapping("/fill-hourly")
+    @Operation(summary = "Hourly 누락 데이터 채우기", description = "지정된 시간의 누락된 Hourly 집계 데이터를 5분 데이터로부터 생성합니다")
     public ResponseEntity<Map<String, Object>> fillHourlyData(
+            @Parameter(description = "대상 시간 (형식: yyyy-MM-dd HH:mm:ss)")
             @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime timeBucket) {
         
         try {
@@ -46,7 +52,9 @@ public class MigrationController {
     }
     
     @PostMapping("/fill-daily")
+    @Operation(summary = "Daily 누락 데이터 채우기", description = "지정된 날짜의 누락된 Daily 집계 데이터를 Hourly 데이터로부터 생성합니다")
     public ResponseEntity<Map<String, Object>> fillDailyData(
+            @Parameter(description = "대상 날짜 (형식: yyyy-MM-dd)")
             @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate date) {
         
         try {
@@ -67,7 +75,9 @@ public class MigrationController {
     }
     
     @GetMapping("/status")
+    @Operation(summary = "마이그레이션 상태 조회", description = "지정된 날짜의 마이그레이션 상태를 조회합니다")
     public ResponseEntity<Map<String, Object>> getStatus(
+            @Parameter(description = "대상 날짜 (형식: yyyy-MM-dd)")
             @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate date) {
         
         String sql = """
@@ -93,11 +103,12 @@ public class MigrationController {
      * - M값이 잘못되었으면(9시간 차이) 수정
      */
     @PostMapping("/fix-unix-timestamps")
+    @Operation(summary = "Unix timestamp 검증 및 수정", description = "track_geom_v2가 비어있거나 M값이 잘못된 레코드를 자동으로 수정합니다")
     public ResponseEntity<Map<String, Object>> fixUnixTimestamps(
-            @RequestParam String tableName,  // "5min", "hourly", "daily"
-            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
-            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime,
-            @RequestParam(defaultValue = "1000") int batchSize) {
+            @Parameter(description = "테이블 타입 (5min, hourly, daily)") @RequestParam String tableName,
+            @Parameter(description = "시작 시간") @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
+            @Parameter(description = "종료 시간") @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime,
+            @Parameter(description = "배치 크기") @RequestParam(defaultValue = "1000") int batchSize) {
         
         try {
             FixResult result = missingDataFiller.fixUnixTimestamps(tableName, startTime, endTime, batchSize);
@@ -125,9 +136,10 @@ public class MigrationController {
      * Unix timestamp 검증 (수정 없이 확인만)
      */
     @GetMapping("/verify-unix-timestamps")
+    @Operation(summary = "Unix timestamp 검증", description = "지정된 테이블과 시간의 Unix timestamp 정합성을 검증합니다 (수정 없음)")
     public ResponseEntity<Map<String, Object>> verifyUnixTimestamps(
-            @RequestParam String tableName,
-            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime timeBucket) {
+            @Parameter(description = "테이블 타입 (5min, hourly, daily)") @RequestParam String tableName,
+            @Parameter(description = "대상 시간") @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime timeBucket) {
         
         try {
             VerifyResult result = missingDataFiller.verifyUnixTimestamps(tableName, timeBucket);
diff --git a/src/main/java/gc/mda/signal_batch/monitoring/controller/MonitoringController.java b/src/main/java/gc/mda/signal_batch/monitoring/controller/MonitoringController.java
index 38853d1..713ae18 100644
--- a/src/main/java/gc/mda/signal_batch/monitoring/controller/MonitoringController.java
+++ b/src/main/java/gc/mda/signal_batch/monitoring/controller/MonitoringController.java
@@ -1,5 +1,7 @@
 package gc.mda.signal_batch.monitoring.controller;
 
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
@@ -14,6 +16,7 @@ import java.util.*;
 @RequestMapping("/monitor")
 @RequiredArgsConstructor
 @ConditionalOnProperty(name = "vessel.batch.scheduler.enabled", havingValue = "true", matchIfMissing = true)
+@Tag(name = "시스템 모니터링 API", description = "데이터 처리 지연, 해구별 현황, 처리량 및 데이터 품질 모니터링 API")
 public class MonitoringController {
 
     private final JdbcTemplate collectJdbcTemplate;
@@ -23,6 +26,7 @@ public class MonitoringController {
      * 데이터 처리 지연 상태 확인
      */
     @GetMapping("/delay")
+    @Operation(summary = "데이터 처리 지연 상태", description = "수집DB와 조회DB 간의 데이터 처리 지연 시간을 확인합니다")
     public Map<String, Object> getProcessingDelay() {
         Map<String, Object> result = new HashMap<>();
         
@@ -76,6 +80,7 @@ public class MonitoringController {
      * 대해구별 실시간 처리 현황
      */
     @GetMapping("/haegu/realtime")
+    @Operation(summary = "대해구별 실시간 현황", description = "최신 타일 데이터 기준 대해구별 선박 통계를 조회합니다")
     public List<Map<String, Object>> getRealtimeHaeguStatus() {
         String sql = """
             WITH recent_data AS (
@@ -123,6 +128,7 @@ public class MonitoringController {
      * 시스템 처리량 메트릭
      */
     @GetMapping("/throughput")
+    @Operation(summary = "시스템 처리량 메트릭", description = "최근 1시간 처리량 및 파티션 크기 정보를 조회합니다")
     public Map<String, Object> getThroughputMetrics() {
         Map<String, Object> metrics = new HashMap<>();
         
@@ -185,6 +191,7 @@ public class MonitoringController {
      */
     @SuppressWarnings("null")
     @GetMapping("/quality")
+    @Operation(summary = "데이터 품질 검증", description = "중복 데이터 및 누락 타일을 확인하여 데이터 품질을 검증합니다")
     public Map<String, Object> checkDataQuality() {
         Map<String, Object> quality = new HashMap<>();
         
diff --git a/src/main/java/gc/mda/signal_batch/monitoring/controller/WebSocketMonitoringController.java b/src/main/java/gc/mda/signal_batch/monitoring/controller/WebSocketMonitoringController.java
index bba7c5d..6ffe1da 100644
--- a/src/main/java/gc/mda/signal_batch/monitoring/controller/WebSocketMonitoringController.java
+++ b/src/main/java/gc/mda/signal_batch/monitoring/controller/WebSocketMonitoringController.java
@@ -2,6 +2,9 @@ package gc.mda.signal_batch.monitoring.controller;
 
 import gc.mda.signal_batch.monitoring.service.TrackStreamingMetrics;
 import gc.mda.signal_batch.global.websocket.service.StompTrackStreamingService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
@@ -16,6 +19,7 @@ import java.util.Map;
 @RestController
 @RequestMapping("/api/websocket")
 @RequiredArgsConstructor
+@Tag(name = "WebSocket 모니터링 API", description = "WebSocket 스트리밍 상태 및 쿼리 진행 상황 모니터링 API")
 public class WebSocketMonitoringController {
 
     private final TrackStreamingMetrics trackStreamingMetrics;
@@ -25,6 +29,7 @@ public class WebSocketMonitoringController {
      * WebSocket 스트리밍 현황 조회
      */
     @GetMapping("/status")
+    @Operation(summary = "WebSocket 스트리밍 현황", description = "활성 쿼리 수, 메모리 사용량, 서버 시간 등 WebSocket 스트리밍 전반의 상태를 조회합니다")
     public ResponseEntity<Map<String, Object>> getStreamingStatus() {
         Map<String, Object> status = new HashMap<>();
         
@@ -50,7 +55,9 @@ public class WebSocketMonitoringController {
      * 특정 쿼리의 상태 조회
      */
     @GetMapping("/query/{queryId}/status")
-    public ResponseEntity<Map<String, Object>> getQueryStatus(@PathVariable String queryId) {
+    @Operation(summary = "쿼리 상태 조회", description = "특정 WebSocket 쿼리의 진행 상태, 메시지, 진행률, 스트리밍된 항적 수를 조회합니다")
+    public ResponseEntity<Map<String, Object>> getQueryStatus(
+            @Parameter(description = "쿼리 ID") @PathVariable String queryId) {
         Map<String, Object> result = new HashMap<>();
         
         var queryStatus = trackStreamingService.getQueryStatus(queryId);
@@ -66,6 +73,7 @@ public class WebSocketMonitoringController {
      * WebSocket 테스트 페이지로 리다이렉트
      */
     @GetMapping("/test")
+    @Operation(summary = "WebSocket 테스트 페이지", description = "WebSocket 스트리밍 테스트 페이지로 리다이렉트합니다")
     public RedirectView redirectToTestPage() {
         return new RedirectView("/websocket/track-streaming-test.html");
     }
diff --git a/src/main/java/gc/mda/signal_batch/monitoring/service/BatchMetadataCleanupService.java b/src/main/java/gc/mda/signal_batch/monitoring/service/BatchMetadataCleanupService.java
index ea80a7a..7740a41 100644
--- a/src/main/java/gc/mda/signal_batch/monitoring/service/BatchMetadataCleanupService.java
+++ b/src/main/java/gc/mda/signal_batch/monitoring/service/BatchMetadataCleanupService.java
@@ -5,6 +5,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Profile;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
@@ -21,6 +22,7 @@ import java.time.format.DateTimeFormatter;
  */
 @Slf4j
 @Service
+@Profile("!query")  // query 프로파일에서는 배치 메타데이터 정리 비활성화
 @ConditionalOnProperty(name = "vessel.batch.scheduler.enabled", havingValue = "true", matchIfMissing = true)
 public class BatchMetadataCleanupService {
 
diff --git a/src/main/resources/application-dev.yml b/src/main/resources/application-dev.yml
index e564482..e698a60 100644
--- a/src/main/resources/application-dev.yml
+++ b/src/main/resources/application-dev.yml
@@ -102,6 +102,9 @@ logging:
 
 # 개발 환경 배치 설정 (성능 최적화)
 vessel:  # spring 하위가 아닌 최상위 레벨
+  # 통합선박 설정
+  integration:
+    enabled: true  # 통합선박 기능 활성화 여부
   batch:
     # Area Statistics 처리를 위한 별도 설정
     area-statistics:
@@ -194,6 +197,12 @@ vessel:  # spring 하위가 아닌 최상위 레벨
         cache-enabled: true
         cache-size: 2000
 
+    cache:
+      latest-position:
+        enabled: true                # 운영 환경: 활성화
+        ttl-minutes: 60              # 60분 TTL
+        max-size: 80000              # 최대 50,000척
+        refresh-interval-minutes: 2  # 2분치 데이터 조회 (수집 지연 고려)
     
     # 비정상 궤적 검출 설정 (개선됨)
     abnormal-detection:
diff --git a/src/main/resources/application-local.yml b/src/main/resources/application-local.yml
index ad13fcf..e2630fa 100644
--- a/src/main/resources/application-local.yml
+++ b/src/main/resources/application-local.yml
@@ -1,20 +1,42 @@
+# 로컬 개발 환경 설정
+# 단일 PostgreSQL 인스턴스를 모든 DataSource가 공유
 server:
   port: 8090
 
 spring:
-  # 로컬 환경에서는 하나의 DB만 사용
   datasource:
-    url: jdbc:postgresql://localhost:5432/mdadb2?stringtype=unspecified&currentSchema=signal&TimeZone=Asia/Seoul
-    username: mda
-    password: mda#8932
-    driver-class-name: org.postgresql.Driver
-    hikari:
-      pool-name: LocalHikariPool
-      connection-timeout: 30000
-      idle-timeout: 600000
-      max-lifetime: 1800000
-      maximum-pool-size: 20
-      minimum-idle: 5
+    # 로컬 수집 DB (동일 DB 사용)
+    collect:
+      jdbc-url: jdbc:postgresql://localhost:5432/mdadb2?stringtype=unspecified&currentSchema=signal&TimeZone=Asia/Seoul
+      username: mda
+      password: mda#8932
+      driver-class-name: org.postgresql.Driver
+      hikari:
+        pool-name: LocalCollectPool
+        maximum-pool-size: 10
+        minimum-idle: 2
+
+    # 로컬 조회 DB (동일 DB 사용)
+    query:
+      jdbc-url: jdbc:postgresql://localhost:5432/mdadb2?stringtype=unspecified&currentSchema=signal&TimeZone=Asia/Seoul
+      username: mda
+      password: mda#8932
+      driver-class-name: org.postgresql.Driver
+      hikari:
+        pool-name: LocalQueryPool
+        maximum-pool-size: 10
+        minimum-idle: 2
+
+    # 로컬 배치 메타 DB (동일 DB 사용)
+    batch:
+      jdbc-url: jdbc:postgresql://localhost:5432/mdadb2?stringtype=unspecified&currentSchema=signal&TimeZone=Asia/Seoul
+      username: mda
+      password: mda#8932
+      driver-class-name: org.postgresql.Driver
+      hikari:
+        pool-name: LocalBatchPool
+        maximum-pool-size: 5
+        minimum-idle: 1
 
   batch:
     job:
@@ -27,13 +49,35 @@ logging:
   level:
     root: INFO
     gc.mda.signal_batch: DEBUG
+    gc.mda.signal_batch.batch: DEBUG
     org.springframework.batch: DEBUG
     org.springframework.jdbc: DEBUG
     org.springframework.transaction: DEBUG
 
 # 로컬 환경 배치 설정
 vessel:
+  # 통합선박 기능 비활성화 (로컬에서는 테이블 없을 수 있음)
+  integration:
+    enabled: false
+
   batch:
+    # 스케줄러 설정 - 로컬에서는 비활성화
+    scheduler:
+      enabled: false
+      incremental:
+        delay-minutes: 3
+
+    # 비정상 궤적 검출 비활성화
+    abnormal-detection:
+      enabled: false
+
+    # 로컬 최적화 설정
     chunk-size: 1000
     page-size: 1000
-    partition-size: 4  # 로컬에서는 적은 수의 파티션 사용
\ No newline at end of file
+    partition-size: 4
+    fetch-size: 10000
+
+    # 캐시 비활성화
+    cache:
+      latest-position:
+        enabled: false
diff --git a/src/main/resources/application-prod-mpr.yml b/src/main/resources/application-prod-mpr.yml
new file mode 100644
index 0000000..ff1ea83
--- /dev/null
+++ b/src/main/resources/application-prod-mpr.yml
@@ -0,0 +1,278 @@
+server:
+  port: 8090
+  tomcat:
+    threads:
+      max: 200
+      min-spare: 10
+    connection-timeout: 60000    # 60초로 증가
+    max-http-form-post-size: 50MB  # 50MB로 증가
+    max-swallow-size: 50MB         # 50MB로 증가
+    max-connections: 10000         # 최대 연결 수
+    accept-count: 100              # 대기열 크기
+
+spring:
+  datasource:
+    # 원격 수집 DB
+    collect:
+      jdbc-url: jdbc:postgresql://10.26.252.39:5432/mdadb?currentSchema=signal&options=-csearch_path=signal,public&assumeMinServerVersion=12&reWriteBatchedInserts=true
+      username: mda
+      password: mda#8932
+      driver-class-name: org.postgresql.Driver
+      hikari:
+        pool-name: CollectHikariPool
+        connection-timeout: 30000  # 원격 연결이므로 타임아웃 증가
+        idle-timeout: 600000
+        max-lifetime: 1800000
+        maximum-pool-size: 20  # 10 -> 20 증가
+        minimum-idle: 5  # 2 -> 5 증가
+        # 원격 연결 안정성을 위한 추가 설정
+        connection-test-query: SELECT 1
+        validation-timeout: 5000
+        leak-detection-threshold: 60000  # 커넥션 누수 감지 (60초)
+        connection-init-sql: "SET TIME ZONE 'Asia/Seoul'; SET search_path TO signal, public;"
+
+    # 원격 조회 DB
+    query:
+      jdbc-url: jdbc:postgresql://10.29.17.90:5432/mpcdb2?currentSchema=signal&assumeMinServerVersion=12&reWriteBatchedInserts=true
+      username: mpc
+      password: mpc#8932
+      driver-class-name: org.postgresql.Driver
+      hikari:
+        pool-name: QueryHikariPool
+        connection-timeout: 5000
+        idle-timeout: 600000
+        max-lifetime: 1800000
+        maximum-pool-size: 60  # 20 -> 40 증가
+        minimum-idle: 10  # 5 -> 10 증가
+        connection-test-query: SELECT 1
+        validation-timeout: 5000
+        leak-detection-threshold: 60000  # 커넥션 누수 감지 (60초)
+        # PostGIS 함수를 위해 public 스키마를 search_path에 명시적으로 추가
+        connection-init-sql: "SET TIME ZONE 'Asia/Seoul'; SET search_path TO signal, public, pg_catalog;"
+        statement-cache-size: 250
+        data-source-properties:
+          prepareThreshold: 3
+          preparedStatementCacheQueries: 250
+
+    # 로컬 배치 메타 DB
+    batch:
+      jdbc-url: jdbc:postgresql://10.26.252.51:5432/mdadb?currentSchema=public&assumeMinServerVersion=12&reWriteBatchedInserts=true
+      username: mda
+      password: mda#8932
+      driver-class-name: org.postgresql.Driver
+      hikari:
+        pool-name: BatchHikariPool
+        maximum-pool-size: 20  # 10 → 30 증가
+        minimum-idle: 10       # 2 → 10 증가
+        connection-timeout: 30000  # 30초 타임아웃
+        idle-timeout: 600000
+        max-lifetime: 1800000
+        leak-detection-threshold: 60000  # 커넥션 누수 감지 (60초)
+        connection-init-sql: "SET TIME ZONE 'Asia/Seoul'; SET search_path TO public, signal;"
+
+  # Request 크기 설정
+  servlet:
+    multipart:
+      max-file-size: 50MB
+      max-request-size: 50MB
+
+  # Spring Batch 설정
+  batch:
+    job:
+      enabled: false
+    jdbc:
+      initialize-schema: never  # always에서 never로 변경 (이미 수동으로 생성했으므로)
+      table-prefix: BATCH_
+
+logging:
+  level:
+    root: INFO
+    gc.mda.signal_batch: DEBUG
+    gc.mda.signal_batch.global.util: INFO
+    gc.mda.signal_batch.global.websocket.service: INFO
+    gc.mda.signal_batch.batch.writer: INFO
+    gc.mda.signal_batch.batch.reader: INFO
+    gc.mda.signal_batch.batch.processor: INFO
+    gc.mda.signal_batch.domain: INFO
+    gc.mda.signal_batch.monitoring: DEBUG
+    gc.mda.signal_batch.monitoring.controller: INFO
+    org.springframework.batch: INFO
+    org.springframework.jdbc: WARN
+    org.postgresql: WARN
+    com.zaxxer.hikari: INFO
+
+# 개발 환경 배치 설정 (성능 최적화)
+vessel:  # spring 하위가 아닌 최상위 레벨
+  # 통합선박 설정
+  integration:
+    enabled: true  # 통합선박 기능 활성화 여부
+  batch:
+    # Area Statistics 처리를 위한 별도 설정
+    area-statistics:
+      chunk-size: 1000     # 5000 → 1000
+      batch-size: 500      # 새로 추가
+
+    chunk-size: 10000
+    page-size: 5000
+    partition-size: 12
+
+    # 성능 최적화 설정
+    optimization:
+      enabled: true
+      dynamic-chunk-sizing: true
+      memory-optimization: true
+      cache-optimization: true
+      thread-pool-optimization: true
+      # 동적 청크 크기 조정
+      chunk:
+        min-size: 1000
+        max-size: 20000
+        adjustment-factor: 0.2
+      # 메모리 임계값
+      memory:
+        warning-threshold: 70
+        critical-threshold: 85
+        optimization-threshold: 80
+      # 캐시 설정
+      cache:
+        min-hit-rate: 70
+        area-boundary-size: 5000
+
+    # Reader 최적화
+    fetch-size: 200000
+    use-cursor-reader: true
+
+    # Bulk Insert 최적화
+    bulk-insert:
+      batch-size: 10000
+      parallel-threads: 8
+      use-binary-copy: false
+
+    # Writer 설정
+    writer:
+      use-advisory-lock: false
+      parallel-threads: 4
+
+    # 재시도 설정
+    retry:
+      max-attempts: 3
+      initial-interval: 1000
+      max-interval: 10000
+      multiplier: 2
+
+    # 스케줄러 설정
+    scheduler:
+      enabled: true
+      incremental:
+        delay-minutes: 3  # 데이터 수집 지연 고려
+
+    # Batch 메타데이터 정리 설정
+    metadata:
+      cleanup:
+        enabled: true           # 자동 정리 활성화
+        retention-days: 30      # 보존 기간 (30일)
+        dry-run: false         # false: 실제 삭제, true: 테스트만
+
+    # 궤적 비정상 검출 설정
+    track:
+      abnormal-detection:
+        large-gap-threshold-hours: 6      # 이 시간 이상 gap은 연결 안함
+        extreme-speed-threshold: 1000     # 이 속도 이상은 무조건 비정상 (knots)
+        enable-merger-filtering: false    # VesselTrackMerger 필터링 활성화 (기본: false)
+
+    # 타임아웃 설정
+    query-timeout: 1800  # 30분
+    lock:
+      timeout: 30
+      max-retry: 5
+
+    # Health Check 설정
+    health:
+      job-timeout-hours: 2
+      min-partition-count: 1
+
+    # 그리드 설정
+    grid:
+      mode: haegu
+      haegu:
+        cache-enabled: true
+        cache-size: 2000
+
+    # 선박 최신 위치 캐시 설정 (운영 환경 활성화)
+    cache:
+      latest-position:
+        enabled: true                # 운영 환경: 활성화
+        ttl-minutes: 60              # 60분 TTL
+        max-size: 50000              # 최대 50,000척
+        refresh-interval-minutes: 2  # 2분치 데이터 조회 (수집 지연 고려)
+
+
+    # 비정상 궤적 검출 설정 (개선됨)
+    abnormal-detection:
+      enabled: true
+      5min-speed-threshold: 500       # 5분 집계 비정상 속도 임계값 (200 knots로 완화)
+      # 비정상 판정 기준 (명백한 비정상만 검출하도록 완화)
+      thresholds:
+        # 정박/저속 판단 기준
+        min-movement-nm: 0.05          # 최소 이동거리 (정박 판단)
+        stationary-speed-knots: 0.5    # 정박 속도 기준
+
+        # 선박 관련 임계값
+        vessel-physical-limit-knots: 100.0      # 선박 물리적 한계
+        vessel-abnormal-speed-knots: 200.0      # 선박 명백한 비정상 속도
+
+        # 항공기 관련 임계값
+        aircraft-physical-limit-knots: 600.0    # 항공기 물리적 한계
+        aircraft-abnormal-speed-knots: 800.0    # 항공기 명백한 비정상 속도
+
+        # 거리 관련 임계값
+        base-distance-5min-nm: 20.0             # 5분 기준 거리 (20nm로 완화)
+        extreme-distance-5min-nm: 100.0         # 5분간 극단적 이동거리
+
+        # Hourly/Daily 전용 임계값
+        hourly-daily-speed-limit: 500.0         # 시간/일 집계시 극단적 속도만 검출
+
+        # 기타 설정
+        distance-tolerance: 3.0                 # 거리 허용 배수 (3.0으로 완화)
+        time-scaling-method: "sqrt"             # 시간 스케일링 방법 (sqrt)
+      # 캐시 설정
+      cache:
+        previous-track-size: 10000     # 이전 궤적 캐시 크기
+        ttl-hours: 24                  # 캐시 TTL
+      # 처리 옵션
+      processing:
+        remove-abnormal-segments: false  # 비정상 구간 제거 여부
+        save-corrected-tracks: true      # 보정된 궤적 저장 여부
+        exclude-stationary-vessels: true        # 정박 선박 제외 여부
+        lenient-mode: true                      # 관대한 모드 활성화
+
+    # 파티션 관리 설정 (운영 환경 - application.yml 설정 오버라이드)
+    partition:
+      # 운영 환경에서는 더 긴 보관 기간 설정 가능
+      default-retention:
+        daily-partitions-retention-days: 7     # 일별 파티션 7일 보관
+        monthly-partitions-retention-months: 3 # 월별 파티션 3개월 보관
+
+      tables:
+        # 중요 데이터는 더 오래 보관
+        t_area_vessel_tracks:
+          retention-days: 60             # 구역별 선박 항적: 60일
+        t_grid_vessel_tracks:
+          retention-days: 30             # 해구별 선박 항적: 30일
+        t_abnormal_tracks:
+          retention-months: 0            # 비정상 항적: 무한 보관
+
+# 액추에이터 설정
+management:
+  endpoints:
+    web:
+      exposure:
+        include: health,info,metrics,prometheus,env,loggers,threaddump,heapdump,scheduledtasks
+  endpoint:
+    health:
+      show-details: always
+      show-components: always
+  metrics:
+    tags:
+      application: vessel-batch-aggregation
+      environment: prod
\ No newline at end of file
diff --git a/src/main/resources/application-prod.yml b/src/main/resources/application-prod.yml
index be9349d..ae8702c 100644
--- a/src/main/resources/application-prod.yml
+++ b/src/main/resources/application-prod.yml
@@ -1,5 +1,5 @@
 server:
-  port: 8090
+  port: 18090
   tomcat:
     threads:
       max: 200
@@ -14,7 +14,7 @@ spring:
   datasource:
     # 원격 수집 DB
     collect:
-      jdbc-url: jdbc:postgresql://10.26.252.39:5432/mdadb?currentSchema=signal&options=-csearch_path=signal,public&assumeMinServerVersion=12&reWriteBatchedInserts=true
+      jdbc-url: jdbc:postgresql://10.188.171.182:5432/mdadb?currentSchema=signal&options=-csearch_path=signal,public&assumeMinServerVersion=12&reWriteBatchedInserts=true
       username: mda
       password: mda#8932
       driver-class-name: org.postgresql.Driver
@@ -33,9 +33,9 @@ spring:
 
     # 원격 조회 DB
     query:
-      jdbc-url: jdbc:postgresql://10.29.17.90:5432/mpcdb2?currentSchema=signal&assumeMinServerVersion=12&reWriteBatchedInserts=true
-      username: mpc
-      password: mpc#8932
+      jdbc-url: jdbc:postgresql://10.188.171.182:5432/mdadb?currentSchema=signal&assumeMinServerVersion=12&reWriteBatchedInserts=true
+      username: mda
+      password: mda#8932
       driver-class-name: org.postgresql.Driver
       hikari:
         pool-name: QueryHikariPool
@@ -54,9 +54,9 @@ spring:
           prepareThreshold: 3
           preparedStatementCacheQueries: 250
 
-    # 로컬 배치 메타 DB
+    # 로컬 배치 메타 DB (signal 스키마 사용)
     batch:
-      jdbc-url: jdbc:postgresql://10.26.252.51:5432/mdadb?currentSchema=public&assumeMinServerVersion=12&reWriteBatchedInserts=true
+      jdbc-url: jdbc:postgresql://10.188.171.182:5432/mdadb?currentSchema=signal&assumeMinServerVersion=12&reWriteBatchedInserts=true
       username: mda
       password: mda#8932
       driver-class-name: org.postgresql.Driver
@@ -68,7 +68,7 @@ spring:
         idle-timeout: 600000
         max-lifetime: 1800000
         leak-detection-threshold: 60000  # 커넥션 누수 감지 (60초)
-        connection-init-sql: "SET TIME ZONE 'Asia/Seoul'; SET search_path TO public, signal;"
+        connection-init-sql: "SET TIME ZONE 'Asia/Seoul'; SET search_path TO signal, public;"
 
   # Request 크기 설정
   servlet:
@@ -82,7 +82,7 @@ spring:
       enabled: false
     jdbc:
       initialize-schema: never  # always에서 never로 변경 (이미 수동으로 생성했으므로)
-      table-prefix: BATCH_
+      table-prefix: signal.BATCH_
 
 logging:
   level:
@@ -103,6 +103,9 @@ logging:
 
 # 개발 환경 배치 설정 (성능 최적화)
 vessel:  # spring 하위가 아닌 최상위 레벨
+  # 통합선박 설정
+  integration:
+    enabled: true  # 통합선박 기능 활성화 여부
   batch:
     # Area Statistics 처리를 위한 별도 설정
     area-statistics:
@@ -167,13 +170,13 @@ vessel:  # spring 하위가 아닌 최상위 레벨
     metadata:
       cleanup:
         enabled: true           # 자동 정리 활성화
-        retention-days: 30      # 보존 기간 (30일)
+        retention-days: 21      # 보존 기간 (30일)
         dry-run: false         # false: 실제 삭제, true: 테스트만
 
     # 궤적 비정상 검출 설정
     track:
       abnormal-detection:
-        large-gap-threshold-hours: 6      # 이 시간 이상 gap은 연결 안함
+        large-gap-threshold-hours: 4      # 이 시간 이상 gap은 연결 안함
         extreme-speed-threshold: 1000     # 이 속도 이상은 무조건 비정상 (knots)
         enable-merger-filtering: false    # VesselTrackMerger 필터링 활성화 (기본: false)
 
@@ -200,7 +203,7 @@ vessel:  # spring 하위가 아닌 최상위 레벨
       latest-position:
         enabled: true                # 운영 환경: 활성화
         ttl-minutes: 60              # 60분 TTL
-        max-size: 50000              # 최대 50,000척
+        max-size: 60000              # 최대 60,000척
         refresh-interval-minutes: 2  # 2분치 데이터 조회 (수집 지연 고려)
 
 
@@ -238,9 +241,9 @@ vessel:  # spring 하위가 아닌 최상위 레벨
         ttl-hours: 24                  # 캐시 TTL
       # 처리 옵션
       processing:
-        remove-abnormal-segments: false  # 비정상 구간 제거 여부
+        remove-abnormal-segments: true  # 비정상 구간 제거 여부
         save-corrected-tracks: true      # 보정된 궤적 저장 여부
-        exclude-stationary-vessels: true        # 정박 선박 제외 여부
+        exclude-stationary-vessels: false        # 정박 선박 제외 여부
         lenient-mode: true                      # 관대한 모드 활성화
 
     # 파티션 관리 설정 (운영 환경 - application.yml 설정 오버라이드)
diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml
index 5f37e3c..394fc36 100644
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -126,11 +126,17 @@ management:
 
 # 커스텀 설정
 vessel:
+  # 데이터 필터 설정
+  filter:
+    zero-coordinates:
+      enabled: ${FILTER_ZERO_COORDS:false}  # 0 근처 좌표 필터링 (기본: 비활성화)
+      # true일 경우 lat/lon이 -1 ~ 1 범위인 데이터를 제외
+
   # 통합선박 설정
   integration:
-    enabled: ${INTEGRATION_ENABLED:true}  # 통합선박 기능 활성화 여부
+    enabled: ${INTEGRATION_ENABLED:false}  # 통합선박 기능 활성화 여부
     cache:
-      refresh-cron: "0 0 3 * * ?"  # 매일 03:00 갱신
+      refresh-cron: "0 0 6 * * ?"  # 매일 06:00 갱신
 
   batch:
     chunk-size: ${BATCH_CHUNK_SIZE:10000}
@@ -160,7 +166,11 @@ vessel:
 
       # 테이블별 보관 기간 (기본값과 다를 경우만 설정)
       tables:
-        # 일별 파티션 테이블 (단위: 일)
+        # CollectDB 일별 파티션 테이블 (단위: 일)
+        sig_test:
+          retention-days: 14             # 14일 보관
+
+        # QueryDB 일별 파티션 테이블 (단위: 일)
         t_vessel_tracks_5min:
           retention-days: 7              # 7일 보관
         t_area_vessel_tracks:
@@ -180,9 +190,7 @@ vessel:
         t_vessel_tracks_hourly:
           retention-months: 2            # 2개월 보관
         t_vessel_tracks_daily:
-          retention-months: 6            # 6개월 보관
-        t_grid_vessel_tracks_hourly:
-          retention-months: 2            # 2개월 보관
+          retention-months: 60           # 60개월 보관
         t_grid_tracks_summary_hourly:
           retention-months: 2            # 2개월 보관
         t_grid_tracks_summary_daily:
@@ -246,6 +254,11 @@ vessel:
         max-size: 50000              # 최대 선박 수: 50,000척
         refresh-interval-minutes: 2  # 갱신 주기 데이터 범위: 2분치 조회 (수집 지연 고려)
 
+      # 이전 버킷 위치 캐시 설정 (버킷 간 점프 검출용)
+      previous-bucket:
+        ttl-minutes: 120             # 캐시 TTL: 120분 (위성 AIS 30~60분 간격 고려)
+        max-size: 100000             # 최대 선박 수: 100,000척 (2시간 누적 고려)
+
 # Swagger/OpenAPI 설정
 springdoc:
   api-docs:
diff --git a/src/main/resources/static/admin/batch-admin.html b/src/main/resources/static/admin/batch-admin.html
index 2ac82c3..ed58086 100644
--- a/src/main/resources/static/admin/batch-admin.html
+++ b/src/main/resources/static/admin/batch-admin.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Vessel Batch Admin</title>
+    <title>선박 배치 관리</title>
     <!-- Local CSS -->
     <link href="/libs/css/bootstrap.min.css" rel="stylesheet">
     <link href="/libs/css/bootstrap-icons.css" rel="stylesheet">
@@ -129,7 +129,7 @@
 <nav class="navbar navbar-expand-lg navbar-dark bg-dark">
     <div class="container-fluid">
         <a class="navbar-brand" href="#">
-            <i class="bi bi-speedometer2"></i> Vessel Batch Admin
+            <i class="bi bi-speedometer2"></i> 선박 배치 관리
         </a>
         <div class="navbar-nav ms-auto">
             <span class="navbar-text" id="currentTime"></span>
@@ -143,36 +143,36 @@
         <button class="sidebar-toggle" id="sidebarToggle" onclick="toggleSidebar()" title="사이드바 토글">
             <i class="bi bi-chevron-left" id="toggleIcon"></i>
         </button>
-        <div class="list-group">        
-                <a href="#" class="list-group-item list-group-item-action active" data-page="dashboard" title="Dashboard">
-                    <i class="bi bi-speedometer2"></i> <span class="sidebar-text">Dashboard</span>
+        <div class="list-group">
+                <a href="#" class="list-group-item list-group-item-action active" data-page="dashboard" title="대시보드">
+                    <i class="bi bi-speedometer2"></i> <span class="sidebar-text">대시보드</span>
                 </a>
-                <a href="#" class="list-group-item list-group-item-action" data-page="jobs" title="Job Management">
-                    <i class="bi bi-play-circle"></i> <span class="sidebar-text">Job Management</span>
+                <a href="#" class="list-group-item list-group-item-action" data-page="jobs" title="Job 관리">
+                    <i class="bi bi-play-circle"></i> <span class="sidebar-text">Job 관리</span>
                 </a>
-                <a href="#" class="list-group-item list-group-item-action" data-page="history" title="Execution History">
-                    <i class="bi bi-clock-history"></i> <span class="sidebar-text">Execution History</span>
+                <a href="#" class="list-group-item list-group-item-action" data-page="history" title="실행 이력">
+                    <i class="bi bi-clock-history"></i> <span class="sidebar-text">실행 이력</span>
                 </a>
-                <a href="#" class="list-group-item list-group-item-action" data-page="monitoring" title="Monitoring">
-                    <i class="bi bi-graph-up"></i> <span class="sidebar-text">Monitoring</span>
+                <a href="#" class="list-group-item list-group-item-action" data-page="monitoring" title="모니터링">
+                    <i class="bi bi-graph-up"></i> <span class="sidebar-text">모니터링</span>
                 </a>
-                <a href="#" class="list-group-item list-group-item-action" data-page="gis" title="GIS Monitoring">
-                    <i class="bi bi-geo-alt-fill"></i> <span class="sidebar-text">GIS Monitoring</span>
+                <a href="#" class="list-group-item list-group-item-action" data-page="gis" title="GIS 모니터링">
+                    <i class="bi bi-geo-alt-fill"></i> <span class="sidebar-text">GIS 모니터링</span>
                 </a>
-                <a href="#" class="list-group-item list-group-item-action" data-page="websocket" title="WebSocket Test">
-                    <i class="bi bi-broadcast"></i> <span class="sidebar-text">WebSocket Test</span>
+                <a href="#" class="list-group-item list-group-item-action" data-page="websocket" title="WebSocket 테스트">
+                    <i class="bi bi-broadcast"></i> <span class="sidebar-text">WebSocket 테스트</span>
                 </a>
                 <a href="#" class="list-group-item list-group-item-action" data-page="websocket-gis" title="WebSocket GIS">
                     <i class="bi bi-globe2"></i> <span class="sidebar-text">WebSocket GIS</span>
                 </a>
-                <a href="#" class="list-group-item list-group-item-action" data-page="loadtest" title="Load Test">
-                    <i class="bi bi-speedometer"></i> <span class="sidebar-text">Load Test</span>
+                <a href="#" class="list-group-item list-group-item-action" data-page="loadtest" title="부하 테스트">
+                    <i class="bi bi-speedometer"></i> <span class="sidebar-text">부하 테스트</span>
                 </a>
-                <a href="#" class="list-group-item list-group-item-action" data-page="abnormal" title="Abnormal Tracks">
-                    <i class="bi bi-exclamation-triangle"></i> <span class="sidebar-text">Abnormal Tracks</span>
+                <a href="#" class="list-group-item list-group-item-action" data-page="abnormal" title="비정상 궤적">
+                    <i class="bi bi-exclamation-triangle"></i> <span class="sidebar-text">비정상 궤적</span>
                 </a>
-                <a href="#" class="list-group-item list-group-item-action" data-page="settings" title="Settings">
-                    <i class="bi bi-gear"></i> <span class="sidebar-text">Settings</span>
+                <a href="#" class="list-group-item list-group-item-action" data-page="settings" title="설정">
+                    <i class="bi bi-gear"></i> <span class="sidebar-text">설정</span>
                 </a>
             </div>
     </div>
@@ -181,14 +181,14 @@
     <div id="mainContent">
             <!-- Dashboard Page -->
             <div id="dashboard-page" class="page-content">
-                <h2>Dashboard</h2>
+                <h2>대시보드</h2>
 
                 <!-- 요약 카드 -->
                 <div class="row mb-4">
                     <div class="col-md-3">
                         <div class="card metric-card">
                             <div class="card-body">
-                                <h6 class="card-subtitle mb-2 text-muted">Running Jobs</h6>
+                                <h6 class="card-subtitle mb-2 text-muted">실행 중인 Job</h6>
                                 <h2 class="card-title" id="runningJobsCount">0</h2>
                             </div>
                         </div>
@@ -196,7 +196,7 @@
                     <div class="col-md-3">
                         <div class="card metric-card" style="border-color: #28a745;">
                             <div class="card-body">
-                                <h6 class="card-subtitle mb-2 text-muted">Success Rate (24h)</h6>
+                                <h6 class="card-subtitle mb-2 text-muted">성공률 (24시간)</h6>
                                 <h2 class="card-title" id="successRate">0%</h2>
                             </div>
                         </div>
@@ -204,7 +204,7 @@
                     <div class="col-md-3">
                         <div class="card metric-card" style="border-color: #ffc107;">
                             <div class="card-body">
-                                <h6 class="card-subtitle mb-2 text-muted">Records/Hour</h6>
+                                <h6 class="card-subtitle mb-2 text-muted">시간당 처리량</h6>
                                 <h2 class="card-title" id="throughput">0</h2>
                             </div>
                         </div>
@@ -212,19 +212,19 @@
                     <div class="col-md-3">
                         <div class="card metric-card" style="border-color: #dc3545;">
                             <div class="card-body">
-                                <h6 class="card-subtitle mb-2 text-muted">Failed Jobs (24h)</h6>
+                                <h6 class="card-subtitle mb-2 text-muted">실패한 Job (24시간)</h6>
                                 <h2 class="card-title" id="failedCount">0</h2>
                             </div>
                         </div>
                     </div>
                 </div>
-                
+
                 <!-- 궤적 집계 메트릭 -->
                 <div class="row mb-4">
                     <div class="col-md-3">
                         <div class="card metric-card" style="border-color: #17a2b8;">
                             <div class="card-body">
-                                <h6 class="card-subtitle mb-2 text-muted">Active Vessels (1h)</h6>
+                                <h6 class="card-subtitle mb-2 text-muted">활성 선박 (1시간)</h6>
                                 <h2 class="card-title" id="activeVessels">0</h2>
                             </div>
                         </div>
@@ -232,7 +232,7 @@
                     <div class="col-md-3">
                         <div class="card metric-card" style="border-color: #6610f2;">
                             <div class="card-body">
-                                <h6 class="card-subtitle mb-2 text-muted">Total Distance (1h)</h6>
+                                <h6 class="card-subtitle mb-2 text-muted">총 이동거리 (1시간)</h6>
                                 <h2 class="card-title" id="totalDistance">0 nm</h2>
                             </div>
                         </div>
@@ -240,7 +240,7 @@
                     <div class="col-md-3">
                         <div class="card metric-card" style="border-color: #e83e8c;">
                             <div class="card-body">
-                                <h6 class="card-subtitle mb-2 text-muted">Active Haegus</h6>
+                                <h6 class="card-subtitle mb-2 text-muted">활성 대해구</h6>
                                 <h2 class="card-title" id="activeHaegus">0</h2>
                             </div>
                         </div>
@@ -248,7 +248,7 @@
                     <div class="col-md-3">
                         <div class="card metric-card" style="border-color: #fd7e14;">
                             <div class="card-body">
-                                <h6 class="card-subtitle mb-2 text-muted">Abnormal Tracks (24h)</h6>
+                                <h6 class="card-subtitle mb-2 text-muted">비정상 궤적 (24시간)</h6>
                                 <h2 class="card-title" id="abnormalTracks">0</h2>
                             </div>
                         </div>
@@ -258,18 +258,18 @@
                 <!-- 실행 중인 Job -->
                 <div class="card mb-4">
                     <div class="card-header">
-                        <h5><i class="bi bi-activity"></i> Running Jobs</h5>
+                        <h5><i class="bi bi-activity"></i> 실행 중인 Job</h5>
                     </div>
                     <div class="card-body">
                         <div class="table-responsive">
                             <table class="table table-hover" id="runningJobsTable">
                                 <thead>
                                 <tr>
-                                    <th>Job Name</th>
-                                    <th>Execution ID</th>
-                                    <th>Start Time</th>
-                                    <th>Progress</th>
-                                    <th>Actions</th>
+                                    <th>Job 이름</th>
+                                    <th>실행 ID</th>
+                                    <th>시작 시간</th>
+                                    <th>진행률</th>
+                                    <th>작업</th>
                                 </tr>
                                 </thead>
                                 <tbody></tbody>
@@ -283,7 +283,7 @@
                     <div class="col-md-6">
                         <div class="card">
                             <div class="card-header">
-                                <h5>Processing Trend (Last 7 Days)</h5>
+                                <h5>처리량 추이 (최근 7일)</h5>
                             </div>
                             <div class="card-body">
                                 <div class="chart-container">
@@ -295,7 +295,7 @@
                     <div class="col-md-6">
                         <div class="card">
                             <div class="card-header">
-                                <h5>Job Status Distribution</h5>
+                                <h5>Job 상태 분포</h5>
                             </div>
                             <div class="card-body">
                                 <div class="chart-container">
@@ -309,34 +309,34 @@
 
             <!-- Job Management Page -->
             <div id="jobs-page" class="page-content" style="display: none;">
-                <h2>Job Management</h2>
+                <h2>Job 관리</h2>
 
                 <div class="card">
                     <div class="card-body">
-                        <h5>Run New Job</h5>
+                        <h5>새 Job 실행</h5>
                         <form id="runJobForm">
                             <div class="row">
                                 <div class="col-md-3">
-                                    <label>Job Type</label>
+                                    <label>Job 유형</label>
                                     <select class="form-select" id="jobType">
-                                        <option value="vesselAggregationJob">Vessel Aggregation (Position)</option>
-                                        <option value="vesselTrackAggregationJob">Vessel Track Aggregation</option>
-                                        <option value="hourlyAggregationJob">Hourly Aggregation</option>
-                                        <option value="dailyAggregationJob">Daily Aggregation</option>
+                                        <option value="vesselAggregationJob">선박 위치 집계</option>
+                                        <option value="vesselTrackAggregationJob">선박 항적 집계</option>
+                                        <option value="hourlyAggregationJob">시간 집계</option>
+                                        <option value="dailyAggregationJob">일간 집계</option>
                                     </select>
                                 </div>
                                 <div class="col-md-3">
-                                    <label>Start Time</label>
+                                    <label>시작 시간</label>
                                     <input type="datetime-local" class="form-control" id="startTime">
                                 </div>
                                 <div class="col-md-3">
-                                    <label>End Time</label>
+                                    <label>종료 시간</label>
                                     <input type="datetime-local" class="form-control" id="endTime">
                                 </div>
                                 <div class="col-md-3">
                                     <label>&nbsp;</label>
                                     <button type="submit" class="btn btn-primary d-block">
-                                        <i class="bi bi-play-fill"></i> Run Job
+                                        <i class="bi bi-play-fill"></i> Job 실행
                                     </button>
                                 </div>
                             </div>
@@ -345,52 +345,52 @@
                 </div>
 
                 <div class="mt-4">
-                    <h5>Scheduled Jobs</h5>
+                    <h5>예약된 Job</h5>
                     <table class="table">
                         <thead>
                         <tr>
-                            <th>Schedule</th>
-                            <th>Job Name</th>
-                            <th>Next Run</th>
-                            <th>Status</th>
-                            <th>Actions</th>
+                            <th>스케줄</th>
+                            <th>Job 이름</th>
+                            <th>다음 실행</th>
+                            <th>상태</th>
+                            <th>작업</th>
                         </tr>
                         </thead>
                         <tbody>
                         <tr>
                             <td>0 3,8,13,18,23,28,33,38,43,48,53,58 * * * *</td>
-                            <td>Vessel Position Aggregation</td>
+                            <td>선박 위치 집계</td>
                             <td id="nextPosition">-</td>
-                            <td><span class="badge bg-success">Active</span></td>
+                            <td><span class="badge bg-success">활성</span></td>
                             <td>
-                                <button class="btn btn-sm btn-warning">Pause</button>
+                                <button class="btn btn-sm btn-warning">일시정지</button>
                             </td>
                         </tr>
                         <tr>
                             <td>0 4,9,14,19,24,29,34,39,44,49,54,59 * * * *</td>
-                            <td>Vessel Track Aggregation</td>
+                            <td>선박 항적 집계</td>
                             <td id="nextTrack">-</td>
-                            <td><span class="badge bg-success">Active</span></td>
+                            <td><span class="badge bg-success">활성</span></td>
                             <td>
-                                <button class="btn btn-sm btn-warning">Pause</button>
+                                <button class="btn btn-sm btn-warning">일시정지</button>
                             </td>
                         </tr>
                         <tr>
                             <td>0 10 * * * *</td>
-                            <td>Hourly Aggregation</td>
+                            <td>시간 집계</td>
                             <td id="nextHourly">-</td>
-                            <td><span class="badge bg-success">Active</span></td>
+                            <td><span class="badge bg-success">활성</span></td>
                             <td>
-                                <button class="btn btn-sm btn-warning">Pause</button>
+                                <button class="btn btn-sm btn-warning">일시정지</button>
                             </td>
                         </tr>
                         <tr>
                             <td>0 0 1 * * *</td>
-                            <td>Daily Aggregation</td>
+                            <td>일간 집계</td>
                             <td id="nextDaily">-</td>
-                            <td><span class="badge bg-success">Active</span></td>
+                            <td><span class="badge bg-success">활성</span></td>
                             <td>
-                                <button class="btn btn-sm btn-warning">Pause</button>
+                                <button class="btn btn-sm btn-warning">일시정지</button>
                             </td>
                         </tr>
                         </tbody>
@@ -400,26 +400,26 @@
 
             <!-- History Page -->
             <div id="history-page" class="page-content" style="display: none;">
-                <h2>Execution History</h2>
+                <h2>실행 이력</h2>
 
                 <div class="card">
                     <div class="card-body">
                         <div class="row mb-3">
                             <div class="col-md-4">
                                 <input type="text" class="form-control" id="historySearch"
-                                       placeholder="Search by job name...">
+                                       placeholder="Job 이름으로 검색...">
                             </div>
                             <div class="col-md-2">
                                 <select class="form-select" id="historyFilter">
-                                    <option value="">All Status</option>
-                                    <option value="COMPLETED">Completed</option>
-                                    <option value="FAILED">Failed</option>
-                                    <option value="STOPPED">Stopped</option>
+                                    <option value="">전체 상태</option>
+                                    <option value="COMPLETED">완료</option>
+                                    <option value="FAILED">실패</option>
+                                    <option value="STOPPED">중지</option>
                                 </select>
                             </div>
                             <div class="col-md-2">
                                 <button class="btn btn-primary" onclick="loadHistory()">
-                                    <i class="bi bi-arrow-clockwise"></i> Refresh
+                                    <i class="bi bi-arrow-clockwise"></i> 새로고침
                                 </button>
                             </div>
                         </div>
@@ -428,14 +428,14 @@
                             <table class="table table-hover" id="historyTable">
                                 <thead>
                                 <tr>
-                                    <th>Execution ID</th>
-                                    <th>Job Name</th>
-                                    <th>Start Time</th>
-                                    <th>End Time</th>
-                                    <th>Duration</th>
-                                    <th>Status</th>
-                                    <th>Records</th>
-                                    <th>Actions</th>
+                                    <th>실행 ID</th>
+                                    <th>Job 이름</th>
+                                    <th>시작 시간</th>
+                                    <th>종료 시간</th>
+                                    <th>소요 시간</th>
+                                    <th>상태</th>
+                                    <th>레코드</th>
+                                    <th>작업</th>
                                 </tr>
                                 </thead>
                                 <tbody></tbody>
@@ -447,13 +447,13 @@
 
             <!-- Monitoring Page -->
             <div id="monitoring-page" class="page-content" style="display: none;">
-                <h2>Real-time Monitoring</h2>
+                <h2>실시간 모니터링</h2>
 
                 <div class="row">
                     <div class="col-md-8">
                         <div class="card">
                             <div class="card-header">
-                                <h5>Processing Rate</h5>
+                                <h5>처리율</h5>
                             </div>
                             <div class="card-body">
                                 <div class="chart-container">
@@ -465,27 +465,27 @@
                     <div class="col-md-4">
                         <div class="card">
                             <div class="card-header">
-                                <h5>System Metrics</h5>
+                                <h5>시스템 메트릭</h5>
                             </div>
                             <div class="card-body">
                                 <div class="mb-3">
-                                    <label>Memory Usage</label>
+                                    <label>메모리 사용량</label>
                                     <div class="progress">
                                         <div class="progress-bar" id="memoryBar" style="width: 0%">0%</div>
                                     </div>
                                 </div>
                                 <div class="mb-3">
-                                    <label>CPU Usage</label>
+                                    <label>CPU 사용량</label>
                                     <div class="progress">
                                         <div class="progress-bar bg-warning" id="cpuBar" style="width: 0%">0%</div>
                                     </div>
                                 </div>
                                 <div class="mb-3">
-                                    <label>Active Threads</label>
+                                    <label>활성 스레드</label>
                                     <h4 id="activeThreads">0</h4>
                                 </div>
                                 <div class="mb-3">
-                                    <label>DB Connections</label>
+                                    <label>DB 연결</label>
                                     <h4 id="dbConnections">0</h4>
                                 </div>
                             </div>
@@ -516,43 +516,43 @@
 
             <!-- Settings Page -->
             <div id="settings-page" class="page-content" style="display: none;">
-                <h2>Settings</h2>
+                <h2>설정</h2>
 
                 <div class="card">
                     <div class="card-body">
-                        <h5>Batch Configuration</h5>
+                        <h5>배치 설정</h5>
                         <form id="settingsForm">
                             <div class="row">
                                 <div class="col-md-6">
                                     <div class="mb-3">
-                                        <label>Chunk Size</label>
+                                        <label>청크 크기</label>
                                         <input type="number" class="form-control" id="chunkSize" value="10000">
                                     </div>
                                     <div class="mb-3">
-                                        <label>Thread Pool Size</label>
+                                        <label>스레드 풀 크기</label>
                                         <input type="number" class="form-control" id="threadPoolSize" value="8">
                                     </div>
                                     <div class="mb-3">
-                                        <label>Skip Limit</label>
+                                        <label>Skip 제한</label>
                                         <input type="number" class="form-control" id="skipLimit" value="1000">
                                     </div>
                                 </div>
                                 <div class="col-md-6">
                                     <div class="mb-3">
-                                        <label>Query Timeout (seconds)</label>
+                                        <label>쿼리 타임아웃 (초)</label>
                                         <input type="number" class="form-control" id="queryTimeout" value="600">
                                     </div>
                                     <div class="mb-3">
-                                        <label>Lock Timeout (seconds)</label>
+                                        <label>Lock 타임아웃 (초)</label>
                                         <input type="number" class="form-control" id="lockTimeout" value="10">
                                     </div>
                                     <div class="mb-3">
-                                        <label>Partition Retention Days</label>
+                                        <label>파티션 보관 일수</label>
                                         <input type="number" class="form-control" id="retentionDays" value="30">
                                     </div>
                                 </div>
                             </div>
-                            <button type="submit" class="btn btn-primary">Save Settings</button>
+                            <button type="submit" class="btn btn-primary">설정 저장</button>
                         </form>
                     </div>
                 </div>
@@ -566,7 +566,7 @@
     <div class="modal-dialog modal-lg">
         <div class="modal-content">
             <div class="modal-header">
-                <h5 class="modal-title">Job Execution Details</h5>
+                <h5 class="modal-title">Job 실행 상세</h5>
                 <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
             </div>
             <div class="modal-body" id="modalBody">
diff --git a/src/main/resources/static/gis-monitoring.html b/src/main/resources/static/gis-monitoring.html
index 71fd784..20a3e56 100644
--- a/src/main/resources/static/gis-monitoring.html
+++ b/src/main/resources/static/gis-monitoring.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>GIS Monitoring - Vessel Batch</title>
+    <title>GIS 모니터링 - 선박 항적</title>
     <!-- Local CSS -->
     <link href="/libs/css/bootstrap.min.css" rel="stylesheet">
     <link href="/libs/css/bootstrap-icons.css" rel="stylesheet">
@@ -99,6 +99,42 @@
             margin-top: 5px;
         }
 
+        /* Hexagon Legend Styles */
+        .hexagon-legend {
+            display: none;
+        }
+
+        .hexagon-legend .legend-gradient {
+            background: linear-gradient(to right,
+                rgba(1, 152, 189, 0.8) 0%,
+                rgba(73, 227, 206, 0.8) 25%,
+                rgba(216, 254, 181, 0.8) 50%,
+                rgba(254, 237, 177, 0.8) 65%,
+                rgba(254, 173, 84, 0.8) 80%,
+                rgba(209, 55, 78, 0.8) 100%);
+        }
+
+        /* Layer Toggle Button Group */
+        .layer-toggle-group {
+            position: absolute;
+            top: 10px;
+            left: 50%;
+            transform: translateX(-50%);
+            z-index: 1000;
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+            padding: 5px;
+        }
+
+        .layer-toggle-group .btn {
+            min-width: 100px;
+        }
+
+        .layer-toggle-group .btn.active {
+            box-shadow: inset 0 2px 4px rgba(0,0,0,0.2);
+        }
+
         .track-info-panel {
             position: absolute;
             top: 10px;
@@ -257,41 +293,51 @@
 </head>
 <body>
 <div id="mapContainer">
+    <!-- Layer Toggle Buttons -->
+    <div class="layer-toggle-group btn-group" role="group" aria-label="Layer toggle">
+        <button type="button" class="btn btn-primary active" id="gridLayerBtn" onclick="GISApp.setVisualizationMode('grid')">
+            <i class="bi bi-grid-3x3"></i> Grid
+        </button>
+        <button type="button" class="btn btn-outline-primary" id="hexagonLayerBtn" onclick="GISApp.setVisualizationMode('hexagon')">
+            <i class="bi bi-hexagon"></i> Hexagon
+        </button>
+    </div>
+
     <div class="control-panel">
-        <h5 class="mb-3">GIS Monitoring</h5>
+        <h5 class="mb-3">GIS 모니터링</h5>
         <div class="mb-2">
-            <label class="form-label">Time Range</label>
+            <label class="form-label">조회 기간</label>
             <select class="form-select form-select-sm" id="gisTimeRange">
-                <option value="60" selected>Last 1 hour</option>
-                <option value="180">Last 3 hours</option>
-                <option value="360">Last 6 hours</option>
-                <option value="720">Last 12 hours</option>
-                <option value="1440">Last 24 hours</option>
+                <option value="60" selected>최근 1시간</option>
+                <option value="180">최근 3시간</option>
+                <option value="360">최근 6시간</option>
+                <option value="720">최근 12시간</option>
+                <option value="1440">최근 24시간</option>
             </select>
         </div>
         <div class="mb-2">
-            <label class="form-label">Layer Type</label>
+            <label class="form-label">레이어 유형</label>
             <select class="form-select form-select-sm" id="gisLayerType">
-                <option value="haegu">Haegu (대해구)</option>
-                <option value="area">Custom Areas</option>
-                <option value="both" selected>Both</option>
+                <option value="haegu">대해구</option>
+                <option value="area">사용자 정의 구역</option>
+                <option value="both" selected>전체</option>
             </select>
         </div>
         <div class="mb-2">
-            <label class="form-label">Track Period</label>
+            <label class="form-label">항적 조회 기간</label>
             <select class="form-select form-select-sm" id="trackPeriod">
-                <option value="60">Last 1 hour</option>
-                <option value="180">Last 3 hours</option>
-                <option value="360">Last 6 hours</option>
-                <option value="720">Last 12 hours</option>
-                <option value="1440">Last 24 hours</option>
+                <option value="60">최근 1시간</option>
+                <option value="180">최근 3시간</option>
+                <option value="360">최근 6시간</option>
+                <option value="720">최근 12시간</option>
+                <option value="1440">최근 24시간</option>
             </select>
         </div>
         <button class="btn btn-primary btn-sm w-100 mb-2" onclick="GISApp.refreshData()">
-            <i class="bi bi-arrow-clockwise"></i> Refresh
+            <i class="bi bi-arrow-clockwise"></i> 새로고침
         </button>
         <button class="btn btn-success btn-sm w-100" onclick="GISApp.toggleSequentialPanel()">
-            <i class="bi bi-diagram-3"></i> Sequential Passage
+            <i class="bi bi-diagram-3"></i> 순차 통과 분석
         </button>
 
         <!-- Vessel List Section -->
@@ -299,7 +345,7 @@
             <hr>
             <div class="d-flex justify-content-between align-items-center mb-2">
                 <div class="d-flex align-items-center">
-                    <h6 id="vesselListTitle" class="mb-0">Vessels in Area</h6>
+                    <h6 id="vesselListTitle" class="mb-0">구역 내 선박</h6>
                     <span class="selected-count" id="selectedCount" style="display: none;">0</span>
                 </div>
                 <button class="btn btn-sm btn-secondary" onclick="GISApp.hideVesselList()">
@@ -309,28 +355,28 @@
 
             <!-- Sort Controls -->
             <div class="sort-controls">
-                <label class="form-label mb-0 me-2">Sort by:</label>
+                <label class="form-label mb-0 me-2">정렬:</label>
                 <select class="form-select form-select-sm" id="sortBy" style="width: auto;">
                     <option value="id">ID</option>
-                    <option value="speed">Speed</option>
-                    <option value="distance">Distance</option>
+                    <option value="speed">속력</option>
+                    <option value="distance">거리</option>
                 </select>
                 <select class="form-select form-select-sm" id="sortOrder" style="width: auto;">
-                    <option value="asc">Asc</option>
-                    <option value="desc">Desc</option>
+                    <option value="asc">오름차순</option>
+                    <option value="desc">내림차순</option>
                 </select>
             </div>
 
             <!-- Action Buttons -->
             <div class="mb-2">
                 <button class="btn btn-sm btn-primary" onclick="GISApp.selectAllVessels()">
-                    <i class="bi bi-check-all"></i> Select All
+                    <i class="bi bi-check-all"></i> 전체 선택
                 </button>
                 <button class="btn btn-sm btn-secondary" onclick="GISApp.deselectAllVessels()">
-                    <i class="bi bi-x-square"></i> Clear All
+                    <i class="bi bi-x-square"></i> 선택 해제
                 </button>
                 <button class="btn btn-sm btn-success" onclick="GISApp.showSelectedTracks()">
-                    <i class="bi bi-geo-alt"></i> Show Tracks
+                    <i class="bi bi-geo-alt"></i> 항적 표시
                 </button>
             </div>
 
@@ -342,27 +388,27 @@
         <div class="form-check">
             <input class="form-check-input" type="checkbox" id="showTracks">
             <label class="form-check-label" for="showTracks">
-                Show Vessel Tracks
+                선박 항적 표시
             </label>
         </div>
         <div class="form-check">
             <input class="form-check-input" type="checkbox" id="showAllTracks">
             <label class="form-check-label" for="showAllTracks">
-                Show All Tracks
+                전체 항적 표시
             </label>
         </div>
         <div class="form-check">
             <input class="form-check-input" type="checkbox" id="showHeatmap">
             <label class="form-check-label" for="showHeatmap">
-                Show Density Heatmap
+                밀도 히트맵 표시
             </label>
         </div>
 
         <!-- Track Filters -->
         <div class="filter-controls">
-            <h6>Track Filters</h6>
+            <h6>필터 설정</h6>
             <div class="mb-2">
-                <label class="form-label small mb-1">Speed Range (kts)</label>
+                <label class="form-label small mb-1">속력 범위 (kts)</label>
                 <div class="d-flex align-items-center gap-2">
                     <input type="number" class="form-control form-control-sm" id="minSpeedFilter"
                            min="0" max="50" value="0" step="0.5" style="width: 70px;">
@@ -372,7 +418,7 @@
                 </div>
             </div>
             <div class="mb-2">
-                <label class="form-label small mb-1">Distance Range (nm)</label>
+                <label class="form-label small mb-1">거리 범위 (nm)</label>
                 <div class="d-flex align-items-center gap-2">
                     <input type="number" class="form-control form-control-sm" id="minDistFilter"
                            min="0" max="200" value="0" step="1" style="width: 70px;">
@@ -382,41 +428,41 @@
                 </div>
             </div>
             <button class="btn btn-sm btn-primary w-100" onclick="GISApp.applyFilters()">
-                <i class="bi bi-funnel"></i> Apply Filters
+                <i class="bi bi-funnel"></i> 필터 적용
             </button>
             <button class="btn btn-sm btn-secondary w-100 mt-1" onclick="GISApp.resetFilters()">
-                <i class="bi bi-arrow-counterclockwise"></i> Reset Filters
+                <i class="bi bi-arrow-counterclockwise"></i> 필터 초기화
             </button>
         </div>
     </div>
 
     <div class="track-info-panel" id="trackInfoPanel">
-        <h5 id="trackPanelTitle">Area Information</h5>
+        <h5 id="trackPanelTitle">구역 정보</h5>
         <div id="trackPanelContent"></div>
     </div>
 
     <!-- Sequential Passage Panel -->
     <div class="sequential-panel" id="sequentialPanel">
-        <h5 class="mb-3">Sequential Passage Analysis</h5>
-        
+        <h5 class="mb-3">순차 통과 분석</h5>
+
         <div class="mb-3">
-            <label class="form-label">Passage Mode</label>
+            <label class="form-label">통과 모드</label>
             <select class="form-select form-select-sm" id="passageMode">
-                <option value="sequential">Sequential (순차 통과)</option>
-                <option value="all">All Zones (전체 구역)</option>
+                <option value="sequential">순차 통과</option>
+                <option value="all">전체 구역</option>
             </select>
         </div>
 
         <div class="mb-3">
-            <label class="form-label">Zone Type</label>
+            <label class="form-label">구역 유형</label>
             <select class="form-select form-select-sm" id="passageZoneType">
-                <option value="GRID">Haegu (해구)</option>
-                <option value="AREA">Custom Area (사용자정의구역)</option>
+                <option value="GRID">대해구</option>
+                <option value="AREA">사용자 정의 구역</option>
             </select>
         </div>
 
         <div class="mb-3">
-            <label class="form-label">Time Period</label>
+            <label class="form-label">조회 기간</label>
             <div class="row g-2">
                 <div class="col-6">
                     <input type="datetime-local" class="form-control form-control-sm" id="passageStartTime">
@@ -428,30 +474,30 @@
         </div>
 
         <div class="zone-selector">
-            <label class="form-label">Selected Zones (Max 3)</label>
+            <label class="form-label">선택 구역 (최대 3개)</label>
             <div id="selectedZones" class="mb-2"></div>
             <div class="input-group input-group-sm">
-                <input type="text" class="form-control" id="zoneInput" placeholder="Enter zone ID">
+                <input type="text" class="form-control" id="zoneInput" placeholder="구역 ID 입력">
                 <button class="btn btn-outline-secondary" onclick="GISApp.addZone()">
-                    <i class="bi bi-plus"></i> Add
+                    <i class="bi bi-plus"></i> 추가
                 </button>
             </div>
         </div>
 
         <button class="btn btn-primary btn-sm w-100 mb-2" onclick="GISApp.searchSequentialPassage()">
-            <i class="bi bi-search"></i> Search Vessels
+            <i class="bi bi-search"></i> 선박 검색
         </button>
-        
+
         <button class="btn btn-secondary btn-sm w-100" onclick="GISApp.toggleSequentialPanel()">
-            <i class="bi bi-x"></i> Close
+            <i class="bi bi-x"></i> 닫기
         </button>
 
         <div id="sequentialResults" class="mt-3" style="max-height: 300px; overflow-y: auto;"></div>
     </div>
 
-    <div class="legend">
-        <h6>Legend</h6>
-        <div class="mb-2"><strong>Vessel Count</strong></div>
+    <div class="legend" id="gridLegend">
+        <h6>범례</h6>
+        <div class="mb-2"><strong>선박 수</strong></div>
         <div class="legend-gradient"></div>
         <div class="legend-labels">
             <span>0</span>
@@ -463,19 +509,41 @@
         <hr class="my-2">
         <div class="legend-item">
             <div class="legend-color" style="background: rgba(0, 100, 200, 0.5); border: 2px solid #0064C8;"></div>
-            <span>Haegu Areas</span>
+            <span>대해구</span>
         </div>
         <div class="legend-item">
             <div class="legend-color" style="background: rgba(200, 100, 0, 0.5); border: 2px solid #C86400;"></div>
-            <span>Custom Areas</span>
+            <span>사용자 정의 구역</span>
         </div>
         <div class="legend-item">
             <div class="legend-color" style="background: #00ff00;"></div>
-            <span>Vessel Tracks</span>
+            <span>선박 항적</span>
         </div>
         <div class="legend-item">
             <div class="legend-color" style="background: #0080ff;"></div>
-            <span>Selected Tracks</span>
+            <span>선택된 항적</span>
+        </div>
+    </div>
+
+    <!-- Hexagon Layer Legend -->
+    <div class="legend hexagon-legend" id="hexagonLegend">
+        <h6>Hexagon 범례</h6>
+        <div class="mb-2"><strong>선박 밀도</strong></div>
+        <div class="legend-gradient"></div>
+        <div class="legend-labels" id="hexagonLegendLabels">
+            <span>0</span>
+            <span>5</span>
+            <span>10</span>
+            <span>20</span>
+            <span>50+</span>
+        </div>
+        <hr class="my-2">
+        <div id="hexagonStats">
+            <div><strong>총 선박 수:</strong> <span id="hexTotalVessels">0</span></div>
+            <div><strong>셀 당 최대:</strong> <span id="hexMaxCount">0</span></div>
+        </div>
+        <div class="mt-2">
+            <small class="text-muted"><i class="bi bi-info-circle"></i> Hexagon 클릭 시 선박 목록 표시</small>
         </div>
     </div>
 </div>
@@ -491,10 +559,10 @@
 <!-- Context Menu -->
 <div class="context-menu" id="contextMenu">
     <div class="context-menu-item" id="addToSequential">
-        <i class="bi bi-plus-circle"></i> Add to Sequential
+        <i class="bi bi-plus-circle"></i> 순차 통과에 추가
     </div>
     <div class="context-menu-item" id="viewAreaDetails">
-        <i class="bi bi-info-circle"></i> View Details
+        <i class="bi bi-info-circle"></i> 상세 정보 보기
     </div>
 </div>
 
@@ -503,1404 +571,6 @@
 <script src="/libs/js/bootstrap.bundle.min.js"></script>
 <script src="/libs/js/maplibre-gl.js"></script>
 <script src="/libs/js/deck.gl.min.js"></script>
-
-<script>
-// =====================================================
-// GIS Monitoring Application - Optimized Version
-// =====================================================
-
-class GISMonitoringApp {
-    constructor() {
-        this.map = null;
-        this.deckOverlay = null;
-        this.dataManager = new DataManager();
-        this.layerManager = null;
-        this.vesselManager = new VesselManager();
-        this.sequentialManager = new SequentialPassageManager();
-        this.contextMenuTarget = null;
-        this.init();
-    }
-
-    init() {
-        this.initMap();
-        this.bindEvents();
-        this.initDateTime();
-    }
-
-    initMap() {
-        this.map = new maplibregl.Map({
-            container: 'mapContainer',
-            style: {
-                version: 8,
-                sources: {
-                    'local-tiles': {
-                        type: 'raster',
-                        tiles: ['/api/tiles/world/{z}/{x}/{y}.webp'],
-                        tileSize: 256,
-                        attribution: 'Local Tile Server'
-                    }
-                },
-                layers: [{
-                    id: 'base-tiles',
-                    type: 'raster',
-                    source: 'local-tiles',
-                    minzoom: 4,
-                    maxzoom: 14
-                }]
-            },
-            center: [126.0, 35.0],
-            zoom: 6
-        });
-
-        this.deckOverlay = new deck.MapboxOverlay({
-            layers: [],
-            getTooltip: this.getTooltip.bind(this)
-        });
-        
-        this.map.addControl(this.deckOverlay);
-        this.map.on('load', () => this.onMapLoad());
-        
-        this.layerManager = new LayerManager(this.deckOverlay);
-    }
-
-    onMapLoad() {
-        this.refreshData();
-        this.setupMapContextMenu();
-    }
-    
-    setupMapContextMenu() {
-        // Setup right-click detection on map canvas
-        const canvas = this.map.getCanvas();
-        canvas.addEventListener('contextmenu', (e) => {
-            e.preventDefault();
-            const point = [e.offsetX, e.offsetY];
-            
-            // Pick features at the clicked point
-            const pickInfo = this.deckOverlay._deck.pickObject({
-                x: e.offsetX,
-                y: e.offsetY,
-                radius: 1,
-                layerIds: ['haegu-layer', 'area-layer']
-            });
-            
-            if (pickInfo && pickInfo.object) {
-                const layerId = pickInfo.layer.id;
-                const type = layerId === 'haegu-layer' ? 'haegu' : 'area';
-                const clickEvent = {
-                    originalEvent: {
-                        clientX: e.clientX,
-                        clientY: e.clientY
-                    }
-                };
-                this.showContextMenu(clickEvent, type, pickInfo.object.properties);
-            }
-        });
-    }
-
-    bindEvents() {
-        // Layer toggles
-        $('#showTracks').change(() => this.toggleTracks());
-        $('#showAllTracks').change(() => this.toggleAllTracks());
-        $('#showHeatmap').change(() => this.toggleHeatmap());
-        
-        // Layer type change
-        $('#gisLayerType').change(() => this.refreshData());
-        
-        // Sort controls
-        $('#sortBy, #sortOrder').change(() => this.vesselManager.sortAndRender());
-        
-        // Context menu events
-        $(document).on('click', () => $('#contextMenu').hide());
-        
-        // Prevent default right-click menu on map
-        $('#mapContainer').on('contextmenu', (e) => {
-            e.preventDefault();
-            return false;
-        });
-        
-        $('#addToSequential').on('click', () => this.addToSequentialFromContext());
-        $('#viewAreaDetails').on('click', () => this.viewAreaDetailsFromContext());
-    }
-
-    initDateTime() {
-        const now = new Date();
-        const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-        
-        $('#passageStartTime').val(yesterday.toISOString().slice(0, 16));
-        $('#passageEndTime').val(now.toISOString().slice(0, 16));
-    }
-
-    async refreshData() {
-        this.showLoading(true);
-        try {
-            const timeRange = $('#gisTimeRange').val();
-            const layerType = $('#gisLayerType').val();
-            
-            // Parallel data loading
-            const promises = [];
-            
-            if (layerType === 'haegu' || layerType === 'both') {
-                promises.push(this.dataManager.loadHaeguData(timeRange));
-            }
-            
-            if (layerType === 'area' || layerType === 'both') {
-                promises.push(this.dataManager.loadAreaData(timeRange));
-            }
-            
-            await Promise.all(promises);
-            this.layerManager.updateAllLayers(this.dataManager);
-            
-        } catch (error) {
-            console.error('Failed to refresh data:', error);
-            alert('Failed to load GIS data');
-        } finally {
-            this.showLoading(false);
-        }
-    }
-
-    toggleTracks() {
-        if (!$('#showTracks').is(':checked')) {
-            this.vesselManager.clearSelection();
-        }
-        this.layerManager.updateTrackLayer(
-            $('#showTracks').is(':checked') ? this.vesselManager.getTracks() : []
-        );
-    }
-
-    toggleAllTracks() {
-        if ($('#showAllTracks').is(':checked')) {
-            this.loadAllTracks();
-        } else {
-            this.dataManager.clearAllTracks();
-            this.layerManager.updateAllTracksLayer([]);
-        }
-    }
-
-    async loadAllTracks() {
-        this.showLoading(true);
-        try {
-            const timeRange = $('#trackPeriod').val();
-            await this.dataManager.loadAllTracks(timeRange);
-            this.layerManager.updateAllTracksLayer(this.dataManager.getFilteredTracks());
-        } catch (error) {
-            console.error('Failed to load all tracks:', error);
-        } finally {
-            this.showLoading(false);
-        }
-    }
-
-    toggleHeatmap() {
-        if ($('#showHeatmap').is(':checked')) {
-            alert('Density heatmap feature is coming soon!');
-            $('#showHeatmap').prop('checked', false);
-        }
-    }
-
-    showAreaDetails(type, properties) {
-        const panel = $('#trackInfoPanel');
-        const title = $('#trackPanelTitle');
-        const content = $('#trackPanelContent');
-        
-        this.dataManager.setCurrentArea(type, properties.haegu_no || properties.area_id);
-        
-        const areaName = type === 'haegu' ? 
-            `Haegu ${properties.haegu_no}` : 
-            (properties.area_name || properties.area_id);
-        
-        title.text(areaName);
-        content.html(this.generateAreaDetailsHTML(type, properties));
-        panel.show();
-    }
-
-    generateAreaDetailsHTML(type, properties) {
-        const id = type === 'haegu' ? properties.haegu_no : properties.area_id;
-        return `
-            <p><strong>Active Vessels:</strong> ${properties.vessel_count}</p>
-            <p><strong>Total Distance:</strong> ${properties.total_distance.toFixed(2)} nm</p>
-            <hr>
-            <button class="btn btn-sm btn-primary" onclick="GISApp.showVesselList('${type}', '${id}')">
-                <i class="bi bi-list"></i> Show Vessel List
-            </button>
-            <button class="btn btn-sm btn-success ms-2" onclick="GISApp.showVesselPositions('${type}', '${id}')">
-                <i class="bi bi-geo-fill"></i> Show Positions
-            </button>
-            <br><br>
-            <button class="btn btn-sm btn-warning w-100" onclick="GISApp.showAreaAllTracks('${type}', '${id}')">
-                <i class="bi bi-map"></i> Show All Tracks in This Area
-            </button>
-            <br><br>
-            <button class="btn btn-sm btn-secondary w-100" onclick="$('#trackInfoPanel').hide()">
-                <i class="bi bi-x"></i> Close
-            </button>
-        `;
-    }
-
-    async showVesselList(type, id) {
-        const timeRange = $('#gisTimeRange').val();
-        $('#vesselListTitle').text(`Vessels in ${type === 'haegu' ? 'Haegu ' + id : 'Area'} (${timeRange} min)`);
-        $('#vesselListSection').slideDown();
-        
-        this.showLoading(true);
-        try {
-            await this.vesselManager.loadVesselList(type, id, timeRange);
-            this.vesselManager.sortAndRender();
-        } catch (error) {
-            console.error('Failed to load vessel list:', error);
-            $('#vesselListContent').html('<div class="text-danger">Failed to load vessel list</div>');
-        } finally {
-            this.showLoading(false);
-        }
-    }
-
-    async showVesselPositions(type, id) {
-        this.showLoading(true);
-        try {
-            const timeRange = $('#gisTimeRange').val();
-            const positions = await this.dataManager.loadVesselPositions(type, id, timeRange);
-            this.layerManager.updatePositionLayer(positions);
-            
-            if (positions.length > 0) {
-                this.fitBounds(positions.map(p => p.position));
-            }
-        } catch (error) {
-            console.error('Failed to load vessel positions:', error);
-        } finally {
-            this.showLoading(false);
-        }
-    }
-
-    async showAreaAllTracks(type, id) {
-        this.showLoading(true);
-        try {
-            const period = $('#trackPeriod').val();
-            const tracks = await this.dataManager.loadAreaTracks(type, id, period);
-            
-            $('#showTracks').prop('checked', true);
-            this.layerManager.updateTrackLayer(tracks);
-            
-            if (tracks.length > 0) {
-                const allPoints = tracks.flatMap(t => t.path);
-                this.fitBounds(allPoints);
-            }
-            
-            $('#trackPanelTitle').text(`All Tracks in ${type === 'haegu' ? 'Haegu ' + id : 'Area ' + id}`);
-            $('#trackPanelContent').html(this.generateAreaTracksHTML(tracks.length, period));
-            
-        } catch (error) {
-            console.error('Failed to load area tracks:', error);
-        } finally {
-            this.showLoading(false);
-        }
-    }
-
-    generateAreaTracksHTML(trackCount, period) {
-        return `
-            <p><strong>Period:</strong> Last ${period} minutes</p>
-            <p><strong>Total Vessels:</strong> ${trackCount}</p>
-            <hr>
-            <button class="btn btn-sm btn-primary" onclick="GISApp.backToAreaInfo()">
-                <i class="bi bi-arrow-left"></i> Back to Area Info
-            </button>
-            <button class="btn btn-sm btn-secondary ms-2" onclick="GISApp.clearTracks()">
-                <i class="bi bi-x-circle"></i> Clear Tracks
-            </button>
-        `;
-    }
-
-    async showSelectedTracks() {
-        const selected = this.vesselManager.getSelectedVessels();
-        if (selected.size === 0) {
-            alert('Please select at least one vessel');
-            return;
-        }
-        
-        this.showLoading(true);
-        try {
-            const period = $('#trackPeriod').val();
-            const tracks = await this.vesselManager.loadSelectedTracks(period);
-            
-            $('#showTracks').prop('checked', true);
-            this.layerManager.updateTrackLayer(tracks);
-            
-            if (tracks.length > 0) {
-                const allPoints = tracks.flatMap(t => t.path);
-                this.fitBounds(allPoints);
-            }
-            
-            $('#vesselListSection').slideUp();
-            
-        } catch (error) {
-            console.error('Failed to load selected tracks:', error);
-        } finally {
-            this.showLoading(false);
-        }
-    }
-
-    selectAllVessels() {
-        this.vesselManager.selectAll();
-    }
-
-    deselectAllVessels() {
-        this.vesselManager.deselectAll();
-    }
-
-    hideVesselList() {
-        $('#vesselListSection').slideUp();
-    }
-
-    clearTracks() {
-        this.vesselManager.clearSelection();
-        this.dataManager.clearTracks();
-        this.layerManager.updateTrackLayer([]);
-    }
-
-    backToAreaInfo() {
-        const area = this.dataManager.getCurrentArea();
-        if (area) {
-            const stats = area.type === 'haegu' ? 
-                this.dataManager.haeguStats[area.id] : 
-                this.dataManager.areaStats[area.id];
-            
-            if (stats) {
-                this.showAreaDetails(area.type, {
-                    haegu_no: area.id,
-                    area_id: area.id,
-                    vessel_count: stats.vessel_count || 0,
-                    total_distance: stats.total_distance || 0
-                });
-            }
-        }
-    }
-
-    applyFilters() {
-        const filters = {
-            minSpeed: parseFloat($('#minSpeedFilter').val()) || 0,
-            maxSpeed: parseFloat($('#maxSpeedFilter').val()) || 50,
-            minDist: parseFloat($('#minDistFilter').val()) || 0,
-            maxDist: parseFloat($('#maxDistFilter').val()) || 200
-        };
-        
-        this.dataManager.applyFilters(filters);
-        this.vesselManager.applyFilters(filters);
-        
-        this.layerManager.updateTrackLayer(this.vesselManager.getTracks());
-        this.layerManager.updateAllTracksLayer(this.dataManager.getFilteredTracks());
-    }
-
-    resetFilters() {
-        $('#minSpeedFilter').val(0);
-        $('#maxSpeedFilter').val(50);
-        $('#minDistFilter').val(0);
-        $('#maxDistFilter').val(200);
-        
-        this.dataManager.resetFilters();
-        this.vesselManager.resetFilters();
-        this.refreshData();
-    }
-
-    toggleSequentialPanel() {
-        $('#sequentialPanel').toggle();
-    }
-
-    addZone() {
-        this.sequentialManager.addZone($('#zoneInput').val());
-        $('#zoneInput').val('');
-    }
-
-    async searchSequentialPassage() {
-        const mode = $('#passageMode').val();
-        const type = $('#passageZoneType').val();
-        const startTime = $('#passageStartTime').val();
-        const endTime = $('#passageEndTime').val();
-        const zones = this.sequentialManager.getZones();
-        
-        if (zones.length === 0) {
-            alert('Please select at least one zone by right-clicking on the map');
-            return;
-        }
-        
-        if (mode === 'sequential' && zones.length !== 3) {
-            alert('Sequential mode requires exactly 3 zones');
-            return;
-        }
-        
-        this.showLoading(true);
-        try {
-            const results = await this.sequentialManager.search(mode, type, startTime, endTime, zones);
-            this.displaySequentialResults(results);
-            this.sequentialManager.setResults(results);
-        } catch (error) {
-            console.error('Sequential passage search failed:', error);
-            alert('Search failed. Please check your parameters.');
-        } finally {
-            this.showLoading(false);
-        }
-    }
-
-    displaySequentialResults(results) {
-        const container = $('#sequentialResults');
-        console.log('Sequential results:', results);
-        
-        if (!results || (results.passages?.length === 0 && results.vessels?.length === 0)) {
-            container.html('<div class="text-muted">No vessels found</div>');
-            return;
-        }
-        
-        const vessels = results.passages || results.vessels || [];
-        const totalCount = results.totalVessels || vessels.length;
-        
-        let html = `<h6>Found ${totalCount} vessels</h6>`;
-        vessels.forEach(vessel => {
-            const vesselId = vessel.sigSrcCd ? 
-                `${vessel.sigSrcCd}_${vessel.targetId}` : 
-                `${vessel.sig_src_cd}_${vessel.target_id}`;
-            // Check multiple possible field names for ship name
-            const shipName = vessel.vesselInfo?.shipName || 
-                           vessel.vesselInfo?.ship_name || 
-                           vessel.ship_name || 
-                           vesselId; // Use ID as fallback instead of 'Unknown'
-            
-            html += `
-                <div class="vessel-item" data-vessel-id="${vesselId}" style="cursor: pointer;">
-                    <div class="vessel-info">
-                        <strong>${vesselId}</strong><br>
-                        <small>${shipName !== vesselId ? shipName : 'No name available'}</small>
-                    </div>
-                </div>
-            `;
-        });
-        container.html(html);
-        
-        // Bind click events
-        container.find('.vessel-item').on('click', function() {
-            const vesselId = $(this).data('vessel-id');
-            console.log('Selected vessel:', vesselId);
-            GISApp.selectSequentialVessel(vesselId);
-        });
-    }
-
-    async selectSequentialVessel(vesselId) {
-        const [sigSrcCd, ...targetIdParts] = vesselId.split('_');
-        const targetId = targetIdParts.join('_'); // Handle targetIds with underscores
-        const startTime = $('#passageStartTime').val();
-        const endTime = $('#passageEndTime').val();
-        
-        console.log('Loading tracks for:', sigSrcCd, targetId);
-        
-        this.showLoading(true);
-        try {
-            // Use new vessel tracks API
-            const response = await $.ajax({
-                url: '/api/v1/tracks/vessels',
-                method: 'POST',
-                contentType: 'application/json',
-                data: JSON.stringify({
-                    startTime: startTime + ':00',
-                    endTime: endTime + ':00',
-                    vessels: [{
-                        sigSrcCd: sigSrcCd,
-                        targetId: targetId
-                    }]
-                })
-            });
-            
-            console.log('API response:', response);
-            
-            if (response && response.length > 0) {
-                const vesselTrack = response[0];
-                
-                // Convert to path format for deck.gl
-                const trackData = [{
-                    path: vesselTrack.geometry,
-                    vessel_id: vesselTrack.vesselId,
-                    distance: vesselTrack.totalDistance,
-                    avg_speed: vesselTrack.avgSpeed,
-                    max_speed: vesselTrack.maxSpeed,
-                    selected: true
-                }];
-                
-                $('#showTracks').prop('checked', true);
-                this.layerManager.updateTrackLayer(trackData);
-                
-                if (vesselTrack.geometry.length > 0) {
-                    this.fitBounds(vesselTrack.geometry);
-                }
-                
-                // Highlight vessel in results
-                $('#sequentialResults .vessel-item').removeClass('selected');
-                $(`#sequentialResults .vessel-item[data-vessel-id="${vesselId}"]`).addClass('selected');
-                
-                // Show track info
-                console.log(`Track info - Points: ${vesselTrack.pointCount}, Distance: ${vesselTrack.totalDistance} nm, Avg Speed: ${vesselTrack.avgSpeed} kts`);
-            } else {
-                alert('No tracks found for this vessel in the specified time range');
-            }
-        } catch (error) {
-            console.error('Failed to load vessel track:', error);
-            alert('Failed to load vessel track. Please check the time range and try again.');
-        } finally {
-            this.showLoading(false);
-        }
-    }
-
-    fitBounds(coordinates) {
-        if (!coordinates || coordinates.length === 0) return;
-        
-        const bounds = new maplibregl.LngLatBounds();
-        coordinates.forEach(coord => bounds.extend(coord));
-        
-        this.map.fitBounds(bounds, {
-            padding: 50,
-            duration: 1000
-        });
-    }
-
-    getTooltip({object, layer}) {
-        if (!object) return null;
-        
-        let html = null;
-        
-        if (layer.id === 'haegu-layer') {
-            html = `<strong>Haegu ${object.properties.haegu_no}</strong><br>
-                    Vessels: ${object.properties.vessel_count}<br>
-                    Distance: ${object.properties.total_distance.toFixed(1)} nm`;
-        } else if (layer.id === 'area-layer') {
-            html = `<strong>${object.properties.area_name || object.properties.area_id}</strong><br>
-                    Vessels: ${object.properties.vessel_count}<br>
-                    Distance: ${object.properties.total_distance.toFixed(1)} nm`;
-        } else if (layer.id === 'track-layer' || layer.id === 'all-tracks-layer') {
-            html = `<strong>Vessel: ${object.vessel_id}</strong><br>
-                    Avg Speed: ${object.avg_speed.toFixed(1)} kts<br>
-                    Distance: ${object.distance.toFixed(1)} nm`;
-        }
-        
-        return html ? {
-            html: html,
-            style: {
-                backgroundColor: 'rgba(255, 255, 255, 0.95)',
-                color: '#000',
-                fontSize: '12px',
-                padding: '10px',
-                borderRadius: '4px',
-                boxShadow: '0 2px 4px rgba(0,0,0,0.3)'
-            }
-        } : null;
-    }
-
-    showLoading(show) {
-        $('#loadingOverlay').css('display', show ? 'flex' : 'none');
-    }
-    
-    showContextMenu(event, type, properties) {
-        // Save context
-        this.contextMenuTarget = { type, properties };
-        
-        const menu = $('#contextMenu');
-        const addItem = $('#addToSequential');
-        
-        // Check if can add more zones
-        const currentZones = this.sequentialManager.getZones();
-        const zoneId = type === 'haegu' ? 
-            properties.haegu_no.toString() : 
-            properties.area_id;
-        
-        if (currentZones.length >= 3) {
-            addItem.addClass('disabled');
-            addItem.html('<i class="bi bi-x-circle"></i> Max 3 zones');
-        } else if (currentZones.includes(zoneId)) {
-            addItem.addClass('disabled');
-            addItem.html('<i class="bi bi-check-circle"></i> Already added');
-        } else {
-            addItem.removeClass('disabled');
-            addItem.html('<i class="bi bi-plus-circle"></i> Add to Sequential');
-        }
-        
-        // Position context menu
-        menu.css({
-            left: event.originalEvent.clientX + 'px',
-            top: event.originalEvent.clientY + 'px',
-            display: 'block'
-        });
-        
-        console.log('Context menu shown for:', type, zoneId);
-    }
-    
-    addToSequentialFromContext() {
-        if (!this.contextMenuTarget) return;
-        
-        const { type, properties } = this.contextMenuTarget;
-        const zoneId = type === 'haegu' ? 
-            properties.haegu_no.toString() : 
-            properties.area_id;
-        
-        this.sequentialManager.addZone(zoneId);
-        
-        // Show sequential panel if hidden
-        if (!$('#sequentialPanel').is(':visible')) {
-            $('#sequentialPanel').show();
-        }
-        
-        // Update zone type selector
-        $('#passageZoneType').val(type === 'haegu' ? 'GRID' : 'AREA');
-        
-        $('#contextMenu').hide();
-    }
-    
-    viewAreaDetailsFromContext() {
-        if (!this.contextMenuTarget) return;
-        
-        const { type, properties } = this.contextMenuTarget;
-        this.showAreaDetails(type, properties);
-        $('#contextMenu').hide();
-    }
-}
-
-// Data Manager Class
-class DataManager {
-    constructor() {
-        this.haegus = [];
-        this.areas = [];
-        this.haeguStats = {};
-        this.areaStats = {};
-        this.allTracks = [];
-        this.filteredTracks = [];
-        this.currentArea = null;
-    }
-
-    async loadHaeguData(timeRange) {
-        const [boundaries, stats] = await Promise.all([
-            $.get('/api/v1/haegu/boundaries'),
-            $.get(`/api/v1/haegu/vessel-stats?minutes=${timeRange}`)
-        ]);
-        
-        this.haegus = boundaries;
-        this.haeguStats = stats;
-        return { haegus: boundaries, stats };
-    }
-
-    async loadAreaData(timeRange) {
-        const [boundaries, stats] = await Promise.all([
-            $.get('/api/v1/areas/boundaries'),
-            $.get(`/api/v1/areas/vessel-stats?minutes=${timeRange}`)
-        ]);
-        
-        this.areas = boundaries;
-        this.areaStats = stats;
-        return { areas: boundaries, stats };
-    }
-
-    async loadAllTracks(timeRange) {
-        this.allTracks = [];
-        const layerType = $('#gisLayerType').val();
-        
-        const loadPromises = [];
-        
-        if (layerType === 'haegu' || layerType === 'both') {
-            Object.entries(this.haeguStats).forEach(([haeguNo, stats]) => {
-                if (stats.vessel_count > 0) {
-                    loadPromises.push(
-                        $.get(`/api/v1/tracks/haegu/${haeguNo}?minutes=${timeRange}`)
-                            .then(tracks => this.processTracks(tracks, 'haegu', haeguNo))
-                    );
-                }
-            });
-        }
-        
-        if (layerType === 'area' || layerType === 'both') {
-            Object.entries(this.areaStats).forEach(([areaId, stats]) => {
-                if (stats.vessel_count > 0) {
-                    loadPromises.push(
-                        $.get(`/api/v1/tracks/area/${areaId}?minutes=${timeRange}`)
-                            .then(tracks => this.processTracks(tracks, 'area', areaId))
-                    );
-                }
-            });
-        }
-        
-        await Promise.all(loadPromises);
-        this.filteredTracks = [...this.allTracks];
-        return this.filteredTracks;
-    }
-
-    async loadVesselPositions(type, id, timeRange) {
-        const tracks = await $.get(`/api/v1/tracks/${type}/${id}?minutes=${timeRange}`);
-        const latestPositions = {};
-        
-        tracks.forEach(track => {
-            const vesselId = `${track.sig_src_cd}_${track.target_id}`;
-            const path = Utils.parseLineStringM(track.track_geom);
-            
-            if (path.length > 0) {
-                if (!latestPositions[vesselId] || 
-                    new Date(track.time_bucket) > new Date(latestPositions[vesselId].time)) {
-                    latestPositions[vesselId] = {
-                        position: path[path.length - 1],
-                        sig_src_cd: track.sig_src_cd,
-                        target_id: track.target_id,
-                        time: track.time_bucket,
-                        speed: parseFloat(track.avg_speed) || 0
-                    };
-                }
-            }
-        });
-        
-        return Object.values(latestPositions);
-    }
-
-    async loadAreaTracks(type, id, period) {
-        const tracks = await $.get(`/api/v1/tracks/${type}/${id}?minutes=${period}`);
-        const vesselTracks = {};
-        
-        tracks.forEach(track => {
-            const vesselId = `${track.sig_src_cd}_${track.target_id}`;
-            if (!vesselTracks[vesselId]) {
-                vesselTracks[vesselId] = {
-                    vessel_id: vesselId,
-                    tracks: [],
-                    total_distance: 0,
-                    avg_speeds: []
-                };
-            }
-            vesselTracks[vesselId].tracks.push(track);
-            vesselTracks[vesselId].total_distance += parseFloat(track.distance_nm) || 0;
-            vesselTracks[vesselId].avg_speeds.push(parseFloat(track.avg_speed) || 0);
-        });
-        
-        const processedTracks = [];
-        Object.values(vesselTracks).forEach(vessel => {
-            vessel.tracks.sort((a, b) => new Date(a.time_bucket) - new Date(b.time_bucket));
-            
-            const allPoints = [];
-            vessel.tracks.forEach(track => {
-                const points = Utils.parseLineStringM(track.track_geom);
-                allPoints.push(...points);
-            });
-            
-            if (allPoints.length > 0) {
-                const avgSpeed = vessel.avg_speeds.reduce((a, b) => a + b, 0) / vessel.avg_speeds.length;
-                processedTracks.push({
-                    path: allPoints,
-                    vessel_id: vessel.vessel_id,
-                    distance: vessel.total_distance,
-                    avg_speed: avgSpeed,
-                    selected: false
-                });
-            }
-        });
-        
-        return processedTracks;
-    }
-
-    processTracks(tracks, type, areaId) {
-        tracks.forEach(track => {
-            const path = Utils.parseLineStringM(track.track_geom);
-            if (path.length > 0) {
-                this.allTracks.push({
-                    path: path,
-                    vessel_id: `${track.sig_src_cd}_${track.target_id}`,
-                    distance: parseFloat(track.distance_nm) || 0,
-                    avg_speed: parseFloat(track.avg_speed) || 0,
-                    time_bucket: track.time_bucket,
-                    type: type,
-                    area_id: areaId
-                });
-            }
-        });
-    }
-
-    applyFilters(filters) {
-        this.filteredTracks = this.allTracks.filter(track => 
-            track.avg_speed >= filters.minSpeed &&
-            track.avg_speed <= filters.maxSpeed &&
-            track.distance >= filters.minDist &&
-            track.distance <= filters.maxDist
-        );
-    }
-
-    resetFilters() {
-        this.filteredTracks = [...this.allTracks];
-    }
-
-    clearTracks() {
-        this.allTracks = [];
-        this.filteredTracks = [];
-    }
-
-    clearAllTracks() {
-        this.allTracks = [];
-        this.filteredTracks = [];
-    }
-
-    setCurrentArea(type, id) {
-        this.currentArea = { type, id };
-    }
-
-    getCurrentArea() {
-        return this.currentArea;
-    }
-
-    getFilteredTracks() {
-        return this.filteredTracks;
-    }
-}
-
-// Vessel Manager Class
-class VesselManager {
-    constructor() {
-        this.vesselList = [];
-        this.selectedVessels = new Set();
-        this.tracks = [];
-        this.currentArea = null;
-    }
-
-    async loadVesselList(type, id, timeRange) {
-        this.currentArea = { type, id };
-        
-        const tracks = await $.get(`/api/v1/tracks/${type}/${id}?minutes=${timeRange}`);
-        
-        const vessels = tracks.map(t => ({
-            id: `${t.sig_src_cd}_${t.target_id}`,
-            sig_src_cd: t.sig_src_cd,
-            target_id: t.target_id,
-            distance: parseFloat(t.distance_nm) || 0,
-            avg_speed: parseFloat(t.avg_speed) || 0,
-            type: type,
-            area_id: id,
-            track_geom: t.track_geom,
-            time_bucket: t.time_bucket
-        }));
-        
-        // Remove duplicates
-        const uniqueVessels = {};
-        vessels.forEach(v => {
-            if (!uniqueVessels[v.id] || uniqueVessels[v.id].distance < v.distance) {
-                uniqueVessels[v.id] = v;
-            }
-        });
-        
-        this.vesselList = Object.values(uniqueVessels);
-        return this.vesselList;
-    }
-
-    async loadSelectedTracks(period) {
-        this.tracks = [];
-        
-        const trackPromises = [];
-        
-        for (const vessel of this.vesselList) {
-            if (this.selectedVessels.has(vessel.id)) {
-                trackPromises.push(
-                    $.get(`/api/v1/tracks/${vessel.type}/${vessel.area_id}?minutes=${period}`)
-                        .then(tracks => {
-                            const vesselTracks = tracks.filter(t => 
-                                `${t.sig_src_cd}_${t.target_id}` === vessel.id
-                            );
-                            
-                            const allPoints = [];
-                            vesselTracks.forEach(track => {
-                                const points = Utils.parseLineStringM(track.track_geom);
-                                allPoints.push(...points);
-                            });
-                            
-                            if (allPoints.length > 0) {
-                                this.tracks.push({
-                                    path: allPoints,
-                                    vessel_id: vessel.id,
-                                    distance: vesselTracks.reduce((sum, t) => sum + (parseFloat(t.distance_nm) || 0), 0),
-                                    avg_speed: vesselTracks.reduce((sum, t) => sum + (parseFloat(t.avg_speed) || 0), 0) / vesselTracks.length,
-                                    selected: true
-                                });
-                            }
-                        })
-                );
-            }
-        }
-        
-        await Promise.all(trackPromises);
-        return this.tracks;
-    }
-
-    sortAndRender() {
-        const sortBy = $('#sortBy').val();
-        const sortOrder = $('#sortOrder').val();
-        
-        this.vesselList.sort((a, b) => {
-            let compareValue = 0;
-            
-            switch(sortBy) {
-                case 'id':
-                    compareValue = a.id.localeCompare(b.id);
-                    break;
-                case 'speed':
-                    compareValue = a.avg_speed - b.avg_speed;
-                    break;
-                case 'distance':
-                    compareValue = a.distance - b.distance;
-                    break;
-            }
-            
-            return sortOrder === 'asc' ? compareValue : -compareValue;
-        });
-        
-        this.render();
-    }
-
-    render() {
-        const content = $('#vesselListContent');
-        
-        if (this.vesselList.length === 0) {
-            content.html('<div class="text-muted">No vessels found in this area</div>');
-            return;
-        }
-        
-        let html = `<div class="mb-2">Found ${this.vesselList.length} vessels</div>`;
-        
-        this.vesselList.forEach(v => {
-            const isSelected = this.selectedVessels.has(v.id);
-            html += `
-                <div class="vessel-item ${isSelected ? 'selected' : ''}" data-vessel-id="${v.id}">
-                    <input type="checkbox" class="vessel-checkbox"
-                           data-vessel-id="${v.id}"
-                           ${isSelected ? 'checked' : ''}>
-                    <div class="vessel-info">
-                        <strong>${v.id}</strong><br>
-                        <small>
-                            Distance: ${v.distance.toFixed(2)} nm |
-                            Avg Speed: ${v.avg_speed.toFixed(1)} kts
-                        </small>
-                    </div>
-                </div>
-            `;
-        });
-        
-        content.html(html);
-        
-        // Bind events
-        $('.vessel-checkbox').off('change').on('change', function(e) {
-            e.stopPropagation();
-            const vesselId = $(this).data('vessel-id');
-            GISApp.vesselManager.toggleSelection(vesselId);
-        });
-        
-        $('.vessel-item').off('click').on('click', function(e) {
-            if (!$(e.target).is('.vessel-checkbox')) {
-                const checkbox = $(this).find('.vessel-checkbox');
-                checkbox.prop('checked', !checkbox.prop('checked'));
-                const vesselId = $(this).data('vessel-id');
-                GISApp.vesselManager.toggleSelection(vesselId);
-            }
-        });
-        
-        this.updateSelectedCount();
-    }
-
-    toggleSelection(vesselId) {
-        if (this.selectedVessels.has(vesselId)) {
-            this.selectedVessels.delete(vesselId);
-        } else {
-            this.selectedVessels.add(vesselId);
-        }
-        
-        const vesselItem = $(`.vessel-item[data-vessel-id="${vesselId}"]`);
-        const checkbox = vesselItem.find('.vessel-checkbox');
-        
-        if (this.selectedVessels.has(vesselId)) {
-            vesselItem.addClass('selected');
-            checkbox.prop('checked', true);
-        } else {
-            vesselItem.removeClass('selected');
-            checkbox.prop('checked', false);
-        }
-        
-        this.updateSelectedCount();
-    }
-
-    selectAll() {
-        this.vesselList.forEach(v => this.selectedVessels.add(v.id));
-        this.render();
-    }
-
-    deselectAll() {
-        this.selectedVessels.clear();
-        this.render();
-    }
-
-    clearSelection() {
-        this.selectedVessels.clear();
-        this.tracks = [];
-        this.updateSelectedCount();
-    }
-
-    applyFilters(filters) {
-        // Filter current vessel list
-        const originalList = [...this.vesselList];
-        this.vesselList = originalList.filter(v =>
-            v.avg_speed >= filters.minSpeed &&
-            v.avg_speed <= filters.maxSpeed &&
-            v.distance >= filters.minDist &&
-            v.distance <= filters.maxDist
-        );
-        this.render();
-    }
-
-    resetFilters() {
-        if (this.currentArea) {
-            this.loadVesselList(
-                this.currentArea.type, 
-                this.currentArea.id, 
-                $('#gisTimeRange').val()
-            ).then(() => this.sortAndRender());
-        }
-    }
-
-    updateSelectedCount() {
-        const count = this.selectedVessels.size;
-        const countElement = $('#selectedCount');
-        
-        if (count > 0) {
-            countElement.text(count).show();
-        } else {
-            countElement.hide();
-        }
-    }
-
-    getSelectedVessels() {
-        return this.selectedVessels;
-    }
-
-    getTracks() {
-        return this.tracks;
-    }
-}
-
-// Layer Manager Class
-class LayerManager {
-    constructor(deckOverlay) {
-        this.deckOverlay = deckOverlay;
-        this.layers = new Map();
-    }
-
-    updateAllLayers(dataManager) {
-        const layers = [];
-        const layerType = $('#gisLayerType').val();
-        
-        // Haegu layer
-        if ((layerType === 'haegu' || layerType === 'both') && dataManager.haegus.length > 0) {
-            layers.push(this.createHaeguLayer(dataManager.haegus, dataManager.haeguStats));
-        }
-        
-        // Area layer
-        if ((layerType === 'area' || layerType === 'both') && dataManager.areas.length > 0) {
-            layers.push(this.createAreaLayer(dataManager.areas, dataManager.areaStats));
-        }
-        
-        // Add existing track layers if any
-        if (this.layers.has('track-layer')) {
-            layers.push(this.layers.get('track-layer'));
-        }
-        if (this.layers.has('all-tracks-layer')) {
-            layers.push(this.layers.get('all-tracks-layer'));
-        }
-        if (this.layers.has('position-layer')) {
-            layers.push(this.layers.get('position-layer'));
-        }
-        
-        this.deckOverlay.setProps({ layers });
-    }
-
-    createHaeguLayer(haegus, stats) {
-        const layer = new deck.GeoJsonLayer({
-            id: 'haegu-layer',
-            data: {
-                type: 'FeatureCollection',
-                features: haegus.map(haegu => ({
-                    type: 'Feature',
-                    properties: {
-                        haegu_no: haegu.haegu_no,
-                        vessel_count: stats?.[haegu.haegu_no]?.vessel_count || 0,
-                        total_distance: stats?.[haegu.haegu_no]?.total_distance || 0
-                    },
-                    geometry: JSON.parse(haegu.geom_json)
-                }))
-            },
-            filled: true,
-            stroked: true,
-            getFillColor: d => Utils.getVesselCountColor(d.properties.vessel_count),
-            getLineColor: [0, 100, 200, 255],
-            getLineWidth: 2,
-            lineWidthMinPixels: 1,
-            pickable: true,
-            autoHighlight: true,
-            highlightColor: [255, 255, 0, 100],
-            onClick: (info) => {
-                if (info.object) {
-                    GISApp.showAreaDetails('haegu', info.object.properties);
-                }
-                return true;
-            }
-        });
-        
-        this.layers.set('haegu-layer', layer);
-        return layer;
-    }
-
-    createAreaLayer(areas, stats) {
-        const layer = new deck.GeoJsonLayer({
-            id: 'area-layer',
-            data: {
-                type: 'FeatureCollection',
-                features: areas.map(area => ({
-                    type: 'Feature',
-                    properties: {
-                        area_id: area.area_id,
-                        area_name: area.area_name,
-                        vessel_count: stats?.[area.area_id]?.vessel_count || 0,
-                        total_distance: stats?.[area.area_id]?.total_distance || 0
-                    },
-                    geometry: JSON.parse(area.geom_json)
-                }))
-            },
-            filled: true,
-            stroked: true,
-            getFillColor: d => Utils.getVesselCountColor(d.properties.vessel_count),
-            getLineColor: [200, 100, 0, 255],
-            getLineWidth: 3,
-            lineWidthMinPixels: 2,
-            pickable: true,
-            autoHighlight: true,
-            highlightColor: [255, 255, 0, 100],
-            onClick: (info) => {
-                if (info.object) {
-                    GISApp.showAreaDetails('area', info.object.properties);
-                }
-                return true;
-            }
-        });
-        
-        this.layers.set('area-layer', layer);
-        return layer;
-    }
-
-    updateTrackLayer(tracks) {
-        if (!tracks || tracks.length === 0) {
-            this.layers.delete('track-layer');
-        } else {
-            const layer = new deck.PathLayer({
-                id: 'track-layer',
-                data: tracks,
-                getPath: d => d.path,
-                getColor: d => d.selected ? [0, 128, 255, 255] : [0, 255, 0, 255],
-                getWidth: d => d.selected ? 4 : 3,
-                pickable: true,
-                widthMinPixels: 2,
-                widthMaxPixels: 10,
-                capRounded: true,
-                jointRounded: true,
-                billboard: false
-            });
-            
-            this.layers.set('track-layer', layer);
-        }
-        
-        this.updateDeckLayers();
-    }
-
-    updateAllTracksLayer(tracks) {
-        if (!tracks || tracks.length === 0) {
-            this.layers.delete('all-tracks-layer');
-        } else {
-            const layer = new deck.PathLayer({
-                id: 'all-tracks-layer',
-                data: tracks,
-                getPath: d => d.path,
-                getColor: d => {
-                    if (d.avg_speed > 20) return [255, 0, 0, 200];
-                    if (d.avg_speed > 10) return [255, 165, 0, 200];
-                    return [0, 128, 255, 200];
-                },
-                getWidth: 2,
-                pickable: true,
-                widthMinPixels: 1,
-                widthMaxPixels: 5,
-                capRounded: true,
-                jointRounded: true,
-                billboard: false
-            });
-            
-            this.layers.set('all-tracks-layer', layer);
-        }
-        
-        this.updateDeckLayers();
-    }
-
-    updatePositionLayer(positions) {
-        if (!positions || positions.length === 0) {
-            this.layers.delete('position-layer');
-        } else {
-            const layer = new deck.ScatterplotLayer({
-                id: 'position-layer',
-                data: positions,
-                getPosition: d => d.position,
-                getRadius: 4,
-                radiusMinPixels: 3,
-                radiusMaxPixels: 8,
-                getFillColor: [255, 0, 0, 255],
-                getLineColor: [255, 255, 255, 255],
-                lineWidthMinPixels: 1,
-                pickable: true
-            });
-            
-            this.layers.set('position-layer', layer);
-        }
-        
-        this.updateDeckLayers();
-    }
-
-    updateDeckLayers() {
-        this.deckOverlay.setProps({ layers: Array.from(this.layers.values()) });
-    }
-}
-
-// Sequential Passage Manager Class
-class SequentialPassageManager {
-    constructor() {
-        this.zones = [];
-        this.maxZones = 3;
-        this.results = null;
-    }
-
-    addZone(zoneId) {
-        if (!zoneId) return false;
-        
-        if (this.zones.length >= this.maxZones) {
-            alert(`Maximum ${this.maxZones} zones allowed`);
-            return false;
-        }
-        
-        if (this.zones.includes(zoneId)) {
-            alert('Zone already added');
-            return false;
-        }
-        
-        this.zones.push(zoneId);
-        this.renderZones();
-        console.log('Added zone:', zoneId, 'Total zones:', this.zones);
-        return true;
-    }
-
-    removeZone(index) {
-        this.zones.splice(index, 1);
-        this.renderZones();
-    }
-
-    renderZones() {
-        const container = $('#selectedZones');
-        
-        if (this.zones.length === 0) {
-            container.html('<small class="text-muted">No zones selected</small>');
-            return;
-        }
-        
-        let html = '';
-        this.zones.forEach((zone, index) => {
-            html += `
-                <span class="zone-tag">
-                    ${zone}
-                    <span class="remove-zone" onclick="GISApp.sequentialManager.removeZone(${index})">
-                        <i class="bi bi-x"></i>
-                    </span>
-                </span>
-            `;
-        });
-        
-        container.html(html);
-    }
-
-    async search(mode, type, startTime, endTime, zones) {
-        const endpoint = mode === 'sequential' ? 
-            '/api/v1/passages/sequential' : 
-            '/api/v1/passages/all-zones';
-        
-        // Format timestamps properly
-        const formattedStartTime = startTime.includes('T') ? 
-            startTime + ':00' : startTime;
-        const formattedEndTime = endTime.includes('T') ? 
-            endTime + ':00' : endTime;
-        
-        const response = await $.ajax({
-            url: endpoint,
-            method: 'POST',
-            contentType: 'application/json',
-            data: JSON.stringify({
-                type: type,
-                zoneIds: zones,
-                startTime: formattedStartTime,
-                endTime: formattedEndTime
-            })
-        });
-        
-        return response;
-    }
-
-    getZones() {
-        return this.zones;
-    }
-
-    clearZones() {
-        this.zones = [];
-        this.renderZones();
-    }
-    
-    setResults(results) {
-        this.results = results;
-    }
-    
-    getResults() {
-        return this.results;
-    }
-}
-
-// Utility Functions
-class Utils {
-    static parseLineStringM(wkt) {
-        if (!wkt) return [];
-        
-        const matches = wkt.match(/LINESTRING M\s*\((.*)\)/);
-        if (!matches) return [];
-        
-        try {
-            const coords = matches[1].split(',').map(coord => {
-                const parts = coord.trim().split(/\s+/);
-                const lon = parseFloat(parts[0]);
-                const lat = parseFloat(parts[1]);
-                
-                if (isNaN(lon) || isNaN(lat)) return null;
-                
-                return [lon, lat];
-            }).filter(coord => coord !== null);
-            
-            return coords;
-        } catch (error) {
-            console.error('Error parsing LineStringM:', error);
-            return [];
-        }
-    }
-
-    static getVesselCountColor(count) {
-        if (count >= 200) return [255, 69, 0, 150];
-        if (count >= 100) return [255, 165, 0, 150];
-        if (count >= 50) return [255, 215, 0, 150];
-        if (count >= 10) return [144, 238, 144, 150];
-        if (count > 0) return [224, 224, 224, 150];
-        return [224, 224, 224, 50];
-    }
-}
-
-// Initialize Application
-let GISApp;
-$(document).ready(function() {
-    GISApp = new GISMonitoringApp();
-});
-</script>
+<script src="/js/gis-monitoring.js"></script>
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/src/main/resources/static/js/gis-monitoring.js b/src/main/resources/static/js/gis-monitoring.js
new file mode 100644
index 0000000..8840150
--- /dev/null
+++ b/src/main/resources/static/js/gis-monitoring.js
@@ -0,0 +1,1831 @@
+// =====================================================
+// GIS Monitoring Application - Modular Version
+// =====================================================
+
+// =====================================================
+// Main Application Class
+// =====================================================
+class GISMonitoringApp {
+    constructor() {
+        this.map = null;
+        this.deckOverlay = null;
+        this.dataManager = new DataManager();
+        this.layerManager = null;
+        this.vesselManager = new VesselManager();
+        this.sequentialManager = new SequentialPassageManager();
+        this.hexagonManager = new HexagonManager();
+        this.contextMenuTarget = null;
+        this.visualizationMode = 'grid'; // 'grid' or 'hexagon'
+        this.vesselPositions = []; // Store vessel positions for hexagon layer
+        this.init();
+    }
+
+    init() {
+        this.initMap();
+        this.bindEvents();
+        this.initDateTime();
+    }
+
+    initMap() {
+        this.map = new maplibregl.Map({
+            container: 'mapContainer',
+            style: {
+                version: 8,
+                sources: {
+                    'local-tiles': {
+                        type: 'raster',
+                        tiles: ['/api/tiles/world/{z}/{x}/{y}.webp'],
+                        tileSize: 256,
+                        attribution: 'Local Tile Server'
+                    }
+                },
+                layers: [{
+                    id: 'base-tiles',
+                    type: 'raster',
+                    source: 'local-tiles',
+                    minzoom: 4,
+                    maxzoom: 14
+                }]
+            },
+            center: [126.0, 35.0],
+            zoom: 6
+        });
+
+        this.deckOverlay = new deck.MapboxOverlay({
+            layers: [],
+            getTooltip: this.getTooltip.bind(this)
+        });
+
+        this.map.addControl(this.deckOverlay);
+        this.map.on('load', () => this.onMapLoad());
+
+        this.layerManager = new LayerManager(this.deckOverlay);
+    }
+
+    onMapLoad() {
+        this.refreshData();
+        this.setupMapContextMenu();
+    }
+
+    setupMapContextMenu() {
+        const canvas = this.map.getCanvas();
+        canvas.addEventListener('contextmenu', (e) => {
+            e.preventDefault();
+
+            const pickInfo = this.deckOverlay._deck.pickObject({
+                x: e.offsetX,
+                y: e.offsetY,
+                radius: 1,
+                layerIds: ['haegu-layer', 'area-layer']
+            });
+
+            if (pickInfo && pickInfo.object) {
+                const layerId = pickInfo.layer.id;
+                const type = layerId === 'haegu-layer' ? 'haegu' : 'area';
+                const clickEvent = {
+                    originalEvent: {
+                        clientX: e.clientX,
+                        clientY: e.clientY
+                    }
+                };
+                this.showContextMenu(clickEvent, type, pickInfo.object.properties);
+            }
+        });
+    }
+
+    bindEvents() {
+        $('#showTracks').change(() => this.toggleTracks());
+        $('#showAllTracks').change(() => this.toggleAllTracks());
+        $('#showHeatmap').change(() => this.toggleHeatmap());
+        $('#gisLayerType').change(() => this.refreshData());
+        $('#sortBy, #sortOrder').change(() => this.vesselManager.sortAndRender());
+
+        $(document).on('click', () => $('#contextMenu').hide());
+
+        $('#mapContainer').on('contextmenu', (e) => {
+            e.preventDefault();
+            return false;
+        });
+
+        $('#addToSequential').on('click', () => this.addToSequentialFromContext());
+        $('#viewAreaDetails').on('click', () => this.viewAreaDetailsFromContext());
+    }
+
+    initDateTime() {
+        const now = new Date();
+        const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+
+        $('#passageStartTime').val(yesterday.toISOString().slice(0, 16));
+        $('#passageEndTime').val(now.toISOString().slice(0, 16));
+    }
+
+    async refreshData() {
+        this.showLoading(true);
+        try {
+            const timeRange = $('#gisTimeRange').val();
+            const layerType = $('#gisLayerType').val();
+
+            const promises = [];
+
+            if (layerType === 'haegu' || layerType === 'both') {
+                promises.push(this.dataManager.loadHaeguData(timeRange));
+            }
+
+            if (layerType === 'area' || layerType === 'both') {
+                promises.push(this.dataManager.loadAreaData(timeRange));
+            }
+
+            await Promise.all(promises);
+
+            // Update visualization based on current mode
+            if (this.visualizationMode === 'hexagon') {
+                await this.updateVisualization();
+            } else {
+                this.layerManager.updateAllLayers(this.dataManager);
+            }
+
+        } catch (error) {
+            console.error('Failed to refresh data:', error);
+            alert('Failed to load GIS data');
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    toggleTracks() {
+        if (!$('#showTracks').is(':checked')) {
+            this.vesselManager.clearSelection();
+        }
+        this.layerManager.updateTrackLayer(
+            $('#showTracks').is(':checked') ? this.vesselManager.getTracks() : []
+        );
+    }
+
+    toggleAllTracks() {
+        if ($('#showAllTracks').is(':checked')) {
+            this.loadAllTracks();
+        } else {
+            this.dataManager.clearAllTracks();
+            this.layerManager.updateAllTracksLayer([]);
+        }
+    }
+
+    async loadAllTracks() {
+        this.showLoading(true);
+        try {
+            const timeRange = $('#trackPeriod').val();
+            await this.dataManager.loadAllTracks(timeRange);
+            this.layerManager.updateAllTracksLayer(this.dataManager.getFilteredTracks());
+        } catch (error) {
+            console.error('Failed to load all tracks:', error);
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    toggleHeatmap() {
+        if ($('#showHeatmap').is(':checked')) {
+            alert('Density heatmap feature is coming soon!');
+            $('#showHeatmap').prop('checked', false);
+        }
+    }
+
+    // =====================================================
+    // Visualization Mode Methods
+    // =====================================================
+
+    setVisualizationMode(mode) {
+        this.visualizationMode = mode;
+
+        if (mode === 'grid') {
+            $('#gridLayerBtn').addClass('btn-primary active').removeClass('btn-outline-primary');
+            $('#hexagonLayerBtn').addClass('btn-outline-primary').removeClass('btn-primary active');
+            $('#gridLegend').show();
+            $('#hexagonLegend').hide();
+        } else {
+            $('#hexagonLayerBtn').addClass('btn-primary active').removeClass('btn-outline-primary');
+            $('#gridLayerBtn').addClass('btn-outline-primary').removeClass('btn-primary active');
+            $('#gridLegend').hide();
+            $('#hexagonLegend').show();
+        }
+
+        this.updateVisualization();
+    }
+
+    async updateVisualization() {
+        if (this.visualizationMode === 'hexagon') {
+            await this.loadVesselPositionsForHexagon();
+            this.layerManager.updateHexagonLayer(this.vesselPositions, this.hexagonManager);
+        } else {
+            this.layerManager.removeHexagonLayer();
+            this.layerManager.updateAllLayers(this.dataManager);
+        }
+    }
+
+    async loadVesselPositionsForHexagon() {
+        this.showLoading(true);
+        try {
+            const timeRange = $('#gisTimeRange').val();
+            const positions = [];
+
+            const haeguPromises = Object.entries(this.dataManager.haeguStats)
+                .filter(([_, stats]) => stats.vessel_count > 0)
+                .map(async ([haeguNo, _]) => {
+                    try {
+                        const data = await this.dataManager.loadVesselPositions('haegu', haeguNo, timeRange);
+                        data.forEach(p => {
+                            if (p.position && p.position.length >= 2) {
+                                positions.push({
+                                    position: p.position,
+                                    count: 1,
+                                    speed: p.speed || 0,
+                                    vesselId: `${p.sig_src_cd}_${p.target_id}`,
+                                    sig_src_cd: p.sig_src_cd,
+                                    target_id: p.target_id
+                                });
+                            }
+                        });
+                    } catch (e) {
+                        console.warn(`Failed to load positions for haegu ${haeguNo}:`, e);
+                    }
+                });
+
+            await Promise.all(haeguPromises);
+
+            this.vesselPositions = positions;
+            this.hexagonManager.setPositions(positions);
+
+            // Update legend stats
+            $('#hexTotalVessels').text(positions.length);
+
+            console.log(`Loaded ${positions.length} vessel positions for hexagon layer`);
+
+        } catch (error) {
+            console.error('Failed to load vessel positions:', error);
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    // =====================================================
+    // Hexagon Click Handler
+    // =====================================================
+
+    handleHexagonClick(info) {
+        if (!info.object) return;
+
+        const points = info.object.points || [];
+        const count = info.object.elevationValue || info.object.colorValue || points.length;
+
+        console.log('Hexagon clicked:', { count, points: points.length });
+
+        // Get vessels in this hexagon
+        const vessels = this.hexagonManager.getVesselsInHexagon(info.object);
+
+        if (vessels.length === 0) {
+            alert('No vessel data available for this hexagon');
+            return;
+        }
+
+        // Show vessel list
+        this.showHexagonVesselList(vessels, info.coordinate);
+    }
+
+    showHexagonVesselList(vessels, coordinate) {
+        const panel = $('#trackInfoPanel');
+        const title = $('#trackPanelTitle');
+        const content = $('#trackPanelContent');
+
+        // Store for later use
+        this.hexagonManager.setSelectedVessels(vessels);
+
+        title.text(`Vessels in Hexagon (${vessels.length})`);
+
+        let html = `
+            <div class="mb-2">
+                <strong>Location:</strong> ${coordinate[0].toFixed(4)}, ${coordinate[1].toFixed(4)}
+            </div>
+            <hr>
+            <div class="mb-2">
+                <button class="btn btn-sm btn-primary" onclick="GISApp.selectAllHexagonVessels()">
+                    <i class="bi bi-check-all"></i> Select All
+                </button>
+                <button class="btn btn-sm btn-success ms-1" onclick="GISApp.showHexagonVesselTracks()">
+                    <i class="bi bi-geo-alt"></i> Show Tracks
+                </button>
+            </div>
+            <div style="max-height: 300px; overflow-y: auto;">
+        `;
+
+        vessels.forEach((v, idx) => {
+            html += `
+                <div class="vessel-item" data-vessel-id="${v.vesselId}" data-index="${idx}">
+                    <input type="checkbox" class="vessel-checkbox hex-vessel-cb" data-index="${idx}">
+                    <div class="vessel-info">
+                        <strong>${v.vesselId}</strong><br>
+                        <small>Speed: ${(v.speed || 0).toFixed(1)} kts</small>
+                    </div>
+                </div>
+            `;
+        });
+
+        html += `
+            </div>
+            <hr>
+            <button class="btn btn-sm btn-secondary w-100" onclick="$('#trackInfoPanel').hide()">
+                <i class="bi bi-x"></i> Close
+            </button>
+        `;
+
+        content.html(html);
+        panel.show();
+
+        // Bind checkbox events
+        $('.hex-vessel-cb').on('change', function() {
+            const idx = $(this).data('index');
+            GISApp.hexagonManager.toggleVesselSelection(idx);
+        });
+
+        // Bind row click
+        $('#trackPanelContent .vessel-item').on('click', function(e) {
+            if (!$(e.target).is('.vessel-checkbox')) {
+                const cb = $(this).find('.vessel-checkbox');
+                cb.prop('checked', !cb.prop('checked')).trigger('change');
+            }
+        });
+    }
+
+    selectAllHexagonVessels() {
+        this.hexagonManager.selectAllVessels();
+        $('.hex-vessel-cb').prop('checked', true);
+    }
+
+    async showHexagonVesselTracks() {
+        const selected = this.hexagonManager.getSelectedVesselIds();
+
+        if (selected.length === 0) {
+            alert('Please select at least one vessel');
+            return;
+        }
+
+        this.showLoading(true);
+        try {
+            const timeRange = $('#gisTimeRange').val();
+            const trackData = [];
+
+            // Get unique haegu numbers from loaded data
+            const haeguNumbers = Object.keys(this.dataManager.haeguStats)
+                .filter(h => this.dataManager.haeguStats[h].vessel_count > 0);
+
+            // Create a set of selected vessel IDs for quick lookup
+            const selectedVesselIds = new Set(selected.map(v => v.vesselId));
+
+            console.log('Selected vessels:', selectedVesselIds.size, Array.from(selectedVesselIds).slice(0, 3));
+
+            // Load tracks from each haegu and filter by selected vessels
+            for (const haeguNo of haeguNumbers) {
+                try {
+                    const tracks = await $.get(`/api/v1/tracks/haegu/${haeguNo}?minutes=${timeRange}`);
+
+                    tracks.forEach(track => {
+                        const vesselId = `${track.sig_src_cd}_${track.target_id}`;
+
+                        if (selectedVesselIds.has(vesselId)) {
+                            const path = Utils.parseLineStringM(track.track_geom);
+                            if (path.length > 0) {
+                                // Check if we already have this vessel's track
+                                const existing = trackData.find(t => t.vessel_id === vesselId);
+                                if (existing) {
+                                    // Merge paths
+                                    existing.path.push(...path);
+                                    existing.distance += parseFloat(track.distance_nm) || 0;
+                                } else {
+                                    trackData.push({
+                                        path: path,
+                                        vessel_id: vesselId,
+                                        distance: parseFloat(track.distance_nm) || 0,
+                                        avg_speed: parseFloat(track.avg_speed) || 0,
+                                        selected: true
+                                    });
+                                }
+                            }
+                        }
+                    });
+                } catch (e) {
+                    console.warn(`Failed to load tracks from haegu ${haeguNo}:`, e);
+                }
+            }
+
+            console.log('Found tracks for vessels:', trackData.length);
+
+            if (trackData.length > 0) {
+                $('#showTracks').prop('checked', true);
+                this.layerManager.updateTrackLayer(trackData);
+
+                const allPoints = trackData.flatMap(t => t.path);
+                this.fitBounds(allPoints);
+
+                $('#trackInfoPanel').hide();
+            } else {
+                alert('No tracks found for selected vessels in current time range');
+            }
+        } catch (error) {
+            console.error('Failed to load vessel tracks:', error);
+            alert('Failed to load vessel tracks');
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    // =====================================================
+    // Area Details Methods
+    // =====================================================
+
+    showAreaDetails(type, properties) {
+        const panel = $('#trackInfoPanel');
+        const title = $('#trackPanelTitle');
+        const content = $('#trackPanelContent');
+
+        this.dataManager.setCurrentArea(type, properties.haegu_no || properties.area_id);
+
+        const areaName = type === 'haegu' ?
+            `Haegu ${properties.haegu_no}` :
+            (properties.area_name || properties.area_id);
+
+        title.text(areaName);
+        content.html(this.generateAreaDetailsHTML(type, properties));
+        panel.show();
+    }
+
+    generateAreaDetailsHTML(type, properties) {
+        const id = type === 'haegu' ? properties.haegu_no : properties.area_id;
+        return `
+            <p><strong>Active Vessels:</strong> ${properties.vessel_count}</p>
+            <p><strong>Total Distance:</strong> ${properties.total_distance.toFixed(2)} nm</p>
+            <hr>
+            <button class="btn btn-sm btn-primary" onclick="GISApp.showVesselList('${type}', '${id}')">
+                <i class="bi bi-list"></i> Show Vessel List
+            </button>
+            <button class="btn btn-sm btn-success ms-2" onclick="GISApp.showVesselPositions('${type}', '${id}')">
+                <i class="bi bi-geo-fill"></i> Show Positions
+            </button>
+            <br><br>
+            <button class="btn btn-sm btn-warning w-100" onclick="GISApp.showAreaAllTracks('${type}', '${id}')">
+                <i class="bi bi-map"></i> Show All Tracks in This Area
+            </button>
+            <br><br>
+            <button class="btn btn-sm btn-secondary w-100" onclick="$('#trackInfoPanel').hide()">
+                <i class="bi bi-x"></i> Close
+            </button>
+        `;
+    }
+
+    async showVesselList(type, id) {
+        const timeRange = $('#gisTimeRange').val();
+        $('#vesselListTitle').text(`Vessels in ${type === 'haegu' ? 'Haegu ' + id : 'Area'} (${timeRange} min)`);
+        $('#vesselListSection').slideDown();
+
+        this.showLoading(true);
+        try {
+            await this.vesselManager.loadVesselList(type, id, timeRange);
+            this.vesselManager.sortAndRender();
+        } catch (error) {
+            console.error('Failed to load vessel list:', error);
+            $('#vesselListContent').html('<div class="text-danger">Failed to load vessel list</div>');
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    async showVesselPositions(type, id) {
+        this.showLoading(true);
+        try {
+            const timeRange = $('#gisTimeRange').val();
+            const positions = await this.dataManager.loadVesselPositions(type, id, timeRange);
+            this.layerManager.updatePositionLayer(positions);
+
+            if (positions.length > 0) {
+                this.fitBounds(positions.map(p => p.position));
+            }
+        } catch (error) {
+            console.error('Failed to load vessel positions:', error);
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    async showAreaAllTracks(type, id) {
+        this.showLoading(true);
+        try {
+            const period = $('#trackPeriod').val();
+            const tracks = await this.dataManager.loadAreaTracks(type, id, period);
+
+            $('#showTracks').prop('checked', true);
+            this.layerManager.updateTrackLayer(tracks);
+
+            if (tracks.length > 0) {
+                const allPoints = tracks.flatMap(t => t.path);
+                this.fitBounds(allPoints);
+            }
+
+            $('#trackPanelTitle').text(`All Tracks in ${type === 'haegu' ? 'Haegu ' + id : 'Area ' + id}`);
+            $('#trackPanelContent').html(this.generateAreaTracksHTML(tracks.length, period));
+
+        } catch (error) {
+            console.error('Failed to load area tracks:', error);
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    generateAreaTracksHTML(trackCount, period) {
+        return `
+            <p><strong>Period:</strong> Last ${period} minutes</p>
+            <p><strong>Total Vessels:</strong> ${trackCount}</p>
+            <hr>
+            <button class="btn btn-sm btn-primary" onclick="GISApp.backToAreaInfo()">
+                <i class="bi bi-arrow-left"></i> Back to Area Info
+            </button>
+            <button class="btn btn-sm btn-secondary ms-2" onclick="GISApp.clearTracks()">
+                <i class="bi bi-x-circle"></i> Clear Tracks
+            </button>
+        `;
+    }
+
+    async showSelectedTracks() {
+        const selected = this.vesselManager.getSelectedVessels();
+        if (selected.size === 0) {
+            alert('Please select at least one vessel');
+            return;
+        }
+
+        this.showLoading(true);
+        try {
+            const period = $('#trackPeriod').val();
+            const tracks = await this.vesselManager.loadSelectedTracks(period);
+
+            $('#showTracks').prop('checked', true);
+            this.layerManager.updateTrackLayer(tracks);
+
+            if (tracks.length > 0) {
+                const allPoints = tracks.flatMap(t => t.path);
+                this.fitBounds(allPoints);
+            }
+
+            $('#vesselListSection').slideUp();
+
+        } catch (error) {
+            console.error('Failed to load selected tracks:', error);
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    selectAllVessels() {
+        this.vesselManager.selectAll();
+    }
+
+    deselectAllVessels() {
+        this.vesselManager.deselectAll();
+    }
+
+    hideVesselList() {
+        $('#vesselListSection').slideUp();
+    }
+
+    clearTracks() {
+        this.vesselManager.clearSelection();
+        this.dataManager.clearTracks();
+        this.layerManager.updateTrackLayer([]);
+    }
+
+    backToAreaInfo() {
+        const area = this.dataManager.getCurrentArea();
+        if (area) {
+            const stats = area.type === 'haegu' ?
+                this.dataManager.haeguStats[area.id] :
+                this.dataManager.areaStats[area.id];
+
+            if (stats) {
+                this.showAreaDetails(area.type, {
+                    haegu_no: area.id,
+                    area_id: area.id,
+                    vessel_count: stats.vessel_count || 0,
+                    total_distance: stats.total_distance || 0
+                });
+            }
+        }
+    }
+
+    // =====================================================
+    // Filter Methods
+    // =====================================================
+
+    applyFilters() {
+        const filters = {
+            minSpeed: parseFloat($('#minSpeedFilter').val()) || 0,
+            maxSpeed: parseFloat($('#maxSpeedFilter').val()) || 50,
+            minDist: parseFloat($('#minDistFilter').val()) || 0,
+            maxDist: parseFloat($('#maxDistFilter').val()) || 200
+        };
+
+        this.dataManager.applyFilters(filters);
+        this.vesselManager.applyFilters(filters);
+
+        this.layerManager.updateTrackLayer(this.vesselManager.getTracks());
+        this.layerManager.updateAllTracksLayer(this.dataManager.getFilteredTracks());
+    }
+
+    resetFilters() {
+        $('#minSpeedFilter').val(0);
+        $('#maxSpeedFilter').val(50);
+        $('#minDistFilter').val(0);
+        $('#maxDistFilter').val(200);
+
+        this.dataManager.resetFilters();
+        this.vesselManager.resetFilters();
+        this.refreshData();
+    }
+
+    // =====================================================
+    // Sequential Passage Methods
+    // =====================================================
+
+    toggleSequentialPanel() {
+        $('#sequentialPanel').toggle();
+    }
+
+    addZone() {
+        this.sequentialManager.addZone($('#zoneInput').val());
+        $('#zoneInput').val('');
+    }
+
+    async searchSequentialPassage() {
+        const mode = $('#passageMode').val();
+        const type = $('#passageZoneType').val();
+        const startTime = $('#passageStartTime').val();
+        const endTime = $('#passageEndTime').val();
+        const zones = this.sequentialManager.getZones();
+
+        if (zones.length === 0) {
+            alert('Please select at least one zone by right-clicking on the map');
+            return;
+        }
+
+        if (mode === 'sequential' && zones.length !== 3) {
+            alert('Sequential mode requires exactly 3 zones');
+            return;
+        }
+
+        this.showLoading(true);
+        try {
+            const results = await this.sequentialManager.search(mode, type, startTime, endTime, zones);
+            this.displaySequentialResults(results);
+            this.sequentialManager.setResults(results);
+        } catch (error) {
+            console.error('Sequential passage search failed:', error);
+            alert('Search failed. Please check your parameters.');
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    displaySequentialResults(results) {
+        const container = $('#sequentialResults');
+
+        if (!results || (results.passages?.length === 0 && results.vessels?.length === 0)) {
+            container.html('<div class="text-muted">No vessels found</div>');
+            return;
+        }
+
+        const vessels = results.passages || results.vessels || [];
+        const totalCount = results.totalVessels || vessels.length;
+
+        let html = `<h6>Found ${totalCount} vessels</h6>`;
+        vessels.forEach(vessel => {
+            const vesselId = vessel.sigSrcCd ?
+                `${vessel.sigSrcCd}_${vessel.targetId}` :
+                `${vessel.sig_src_cd}_${vessel.target_id}`;
+            const shipName = vessel.vesselInfo?.shipName ||
+                vessel.vesselInfo?.ship_name ||
+                vessel.ship_name ||
+                vesselId;
+
+            html += `
+                <div class="vessel-item" data-vessel-id="${vesselId}" style="cursor: pointer;">
+                    <div class="vessel-info">
+                        <strong>${vesselId}</strong><br>
+                        <small>${shipName !== vesselId ? shipName : 'No name available'}</small>
+                    </div>
+                </div>
+            `;
+        });
+        container.html(html);
+
+        container.find('.vessel-item').on('click', function() {
+            const vesselId = $(this).data('vessel-id');
+            GISApp.selectSequentialVessel(vesselId);
+        });
+    }
+
+    async selectSequentialVessel(vesselId) {
+        const [sigSrcCd, ...targetIdParts] = vesselId.split('_');
+        const targetId = targetIdParts.join('_');
+        const startTime = $('#passageStartTime').val();
+        const endTime = $('#passageEndTime').val();
+
+        this.showLoading(true);
+        try {
+            const response = await $.ajax({
+                url: '/api/v1/tracks/vessels',
+                method: 'POST',
+                contentType: 'application/json',
+                data: JSON.stringify({
+                    startTime: startTime + ':00',
+                    endTime: endTime + ':00',
+                    vessels: [{
+                        sigSrcCd: sigSrcCd,
+                        targetId: targetId
+                    }]
+                })
+            });
+
+            if (response && response.length > 0) {
+                const vesselTrack = response[0];
+
+                const trackData = [{
+                    path: vesselTrack.geometry,
+                    vessel_id: vesselTrack.vesselId,
+                    distance: vesselTrack.totalDistance,
+                    avg_speed: vesselTrack.avgSpeed,
+                    max_speed: vesselTrack.maxSpeed,
+                    selected: true
+                }];
+
+                $('#showTracks').prop('checked', true);
+                this.layerManager.updateTrackLayer(trackData);
+
+                if (vesselTrack.geometry.length > 0) {
+                    this.fitBounds(vesselTrack.geometry);
+                }
+
+                $('#sequentialResults .vessel-item').removeClass('selected');
+                $(`#sequentialResults .vessel-item[data-vessel-id="${vesselId}"]`).addClass('selected');
+            } else {
+                alert('No tracks found for this vessel in the specified time range');
+            }
+        } catch (error) {
+            console.error('Failed to load vessel track:', error);
+            alert('Failed to load vessel track. Please check the time range and try again.');
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    // =====================================================
+    // Context Menu Methods
+    // =====================================================
+
+    showContextMenu(event, type, properties) {
+        this.contextMenuTarget = { type, properties };
+
+        const menu = $('#contextMenu');
+        const addItem = $('#addToSequential');
+
+        const currentZones = this.sequentialManager.getZones();
+        const zoneId = type === 'haegu' ?
+            properties.haegu_no.toString() :
+            properties.area_id;
+
+        if (currentZones.length >= 3) {
+            addItem.addClass('disabled');
+            addItem.html('<i class="bi bi-x-circle"></i> Max 3 zones');
+        } else if (currentZones.includes(zoneId)) {
+            addItem.addClass('disabled');
+            addItem.html('<i class="bi bi-check-circle"></i> Already added');
+        } else {
+            addItem.removeClass('disabled');
+            addItem.html('<i class="bi bi-plus-circle"></i> Add to Sequential');
+        }
+
+        menu.css({
+            left: event.originalEvent.clientX + 'px',
+            top: event.originalEvent.clientY + 'px',
+            display: 'block'
+        });
+    }
+
+    addToSequentialFromContext() {
+        if (!this.contextMenuTarget) return;
+
+        const { type, properties } = this.contextMenuTarget;
+        const zoneId = type === 'haegu' ?
+            properties.haegu_no.toString() :
+            properties.area_id;
+
+        this.sequentialManager.addZone(zoneId);
+
+        if (!$('#sequentialPanel').is(':visible')) {
+            $('#sequentialPanel').show();
+        }
+
+        $('#passageZoneType').val(type === 'haegu' ? 'GRID' : 'AREA');
+
+        $('#contextMenu').hide();
+    }
+
+    viewAreaDetailsFromContext() {
+        if (!this.contextMenuTarget) return;
+
+        const { type, properties } = this.contextMenuTarget;
+        this.showAreaDetails(type, properties);
+        $('#contextMenu').hide();
+    }
+
+    // =====================================================
+    // Utility Methods
+    // =====================================================
+
+    fitBounds(coordinates) {
+        if (!coordinates || coordinates.length === 0) return;
+
+        const bounds = new maplibregl.LngLatBounds();
+        coordinates.forEach(coord => bounds.extend(coord));
+
+        this.map.fitBounds(bounds, {
+            padding: 50,
+            duration: 1000
+        });
+    }
+
+    getTooltip({object, layer}) {
+        if (!object) return null;
+
+        let html = null;
+
+        if (layer.id === 'haegu-layer') {
+            html = `<strong>Haegu ${object.properties.haegu_no}</strong><br>
+                    Vessels: ${object.properties.vessel_count}<br>
+                    Distance: ${object.properties.total_distance.toFixed(1)} nm`;
+        } else if (layer.id === 'area-layer') {
+            html = `<strong>${object.properties.area_name || object.properties.area_id}</strong><br>
+                    Vessels: ${object.properties.vessel_count}<br>
+                    Distance: ${object.properties.total_distance.toFixed(1)} nm`;
+        } else if (layer.id === 'track-layer' || layer.id === 'all-tracks-layer') {
+            html = `<strong>Vessel: ${object.vessel_id}</strong><br>
+                    Avg Speed: ${object.avg_speed.toFixed(1)} kts<br>
+                    Distance: ${object.distance.toFixed(1)} nm`;
+        } else if (layer.id === 'hexagon-layer') {
+            const count = object.elevationValue || object.colorValue || (object.points?.length || 0);
+            html = `<strong>Vessel Density</strong><br>
+                    Count: ${count} vessels<br>
+                    <small><i class="bi bi-hand-index"></i> Click to see vessel list</small>`;
+        }
+
+        return html ? {
+            html: html,
+            style: {
+                backgroundColor: 'rgba(255, 255, 255, 0.95)',
+                color: '#000',
+                fontSize: '12px',
+                padding: '10px',
+                borderRadius: '4px',
+                boxShadow: '0 2px 4px rgba(0,0,0,0.3)'
+            }
+        } : null;
+    }
+
+    showLoading(show) {
+        $('#loadingOverlay').css('display', show ? 'flex' : 'none');
+    }
+}
+
+// =====================================================
+// Hexagon Manager Class
+// =====================================================
+class HexagonManager {
+    constructor() {
+        this.positions = [];
+        this.selectedVessels = [];
+        this.vesselSelectionState = [];
+        this.maxCount = 0;
+    }
+
+    setPositions(positions) {
+        this.positions = positions;
+    }
+
+    getVesselsInHexagon(hexagonObject) {
+        const points = hexagonObject.points || [];
+
+        console.log('Points count:', points.length);
+
+        const vessels = [];
+        const seen = new Set(); // Deduplicate vessels
+
+        for (const p of points) {
+            let source = null;
+
+            // Get source data from point
+            if (p && p.source) {
+                source = p.source;
+            } else if (p && p.sig_src_cd) {
+                source = p;
+            }
+
+            if (source && source.sig_src_cd && source.target_id) {
+                const vesselId = source.vesselId || `${source.sig_src_cd}_${source.target_id}`;
+
+                // Deduplicate by vesselId
+                if (!seen.has(vesselId)) {
+                    seen.add(vesselId);
+                    vessels.push({
+                        vesselId: vesselId,
+                        sig_src_cd: source.sig_src_cd,
+                        target_id: source.target_id,
+                        speed: source.speed || 0,
+                        position: source.position
+                    });
+                }
+            }
+        }
+
+        console.log('Extracted unique vessels:', vessels.length);
+        if (vessels.length > 0) {
+            console.log('Sample vessel:', vessels[0]);
+        }
+
+        return vessels;
+    }
+
+    setSelectedVessels(vessels) {
+        this.selectedVessels = vessels;
+        this.vesselSelectionState = vessels.map(() => false);
+    }
+
+    toggleVesselSelection(index) {
+        if (index >= 0 && index < this.vesselSelectionState.length) {
+            this.vesselSelectionState[index] = !this.vesselSelectionState[index];
+        }
+    }
+
+    selectAllVessels() {
+        this.vesselSelectionState = this.vesselSelectionState.map(() => true);
+    }
+
+    getSelectedVesselIds() {
+        return this.selectedVessels.filter((_, idx) => this.vesselSelectionState[idx]);
+    }
+
+    updateStats(maxCount) {
+        this.maxCount = maxCount;
+        $('#hexMaxCount').text(maxCount);
+
+        // Update legend labels based on max count
+        const step = Math.ceil(maxCount / 4);
+        const labels = [0, step, step * 2, step * 3, maxCount + '+'];
+        const labelElements = $('#hexagonLegendLabels span');
+        labels.forEach((label, idx) => {
+            if (labelElements[idx]) {
+                $(labelElements[idx]).text(label);
+            }
+        });
+    }
+}
+
+// =====================================================
+// Data Manager Class
+// =====================================================
+class DataManager {
+    constructor() {
+        this.haegus = [];
+        this.areas = [];
+        this.haeguStats = {};
+        this.areaStats = {};
+        this.allTracks = [];
+        this.filteredTracks = [];
+        this.currentArea = null;
+    }
+
+    async loadHaeguData(timeRange) {
+        const [boundaries, stats] = await Promise.all([
+            $.get('/api/v1/haegu/boundaries'),
+            $.get(`/api/v1/haegu/vessel-stats?minutes=${timeRange}`)
+        ]);
+
+        this.haegus = boundaries;
+        this.haeguStats = stats;
+        return { haegus: boundaries, stats };
+    }
+
+    async loadAreaData(timeRange) {
+        const [boundaries, stats] = await Promise.all([
+            $.get('/api/v1/areas/boundaries'),
+            $.get(`/api/v1/areas/vessel-stats?minutes=${timeRange}`)
+        ]);
+
+        this.areas = boundaries;
+        this.areaStats = stats;
+        return { areas: boundaries, stats };
+    }
+
+    async loadAllTracks(timeRange) {
+        this.allTracks = [];
+        const layerType = $('#gisLayerType').val();
+
+        const loadPromises = [];
+
+        if (layerType === 'haegu' || layerType === 'both') {
+            Object.entries(this.haeguStats).forEach(([haeguNo, stats]) => {
+                if (stats.vessel_count > 0) {
+                    loadPromises.push(
+                        $.get(`/api/v1/tracks/haegu/${haeguNo}?minutes=${timeRange}`)
+                            .then(tracks => this.processTracks(tracks, 'haegu', haeguNo))
+                    );
+                }
+            });
+        }
+
+        if (layerType === 'area' || layerType === 'both') {
+            Object.entries(this.areaStats).forEach(([areaId, stats]) => {
+                if (stats.vessel_count > 0) {
+                    loadPromises.push(
+                        $.get(`/api/v1/tracks/area/${areaId}?minutes=${timeRange}`)
+                            .then(tracks => this.processTracks(tracks, 'area', areaId))
+                    );
+                }
+            });
+        }
+
+        await Promise.all(loadPromises);
+        this.filteredTracks = [...this.allTracks];
+        return this.filteredTracks;
+    }
+
+    async loadVesselPositions(type, id, timeRange) {
+        const tracks = await $.get(`/api/v1/tracks/${type}/${id}?minutes=${timeRange}`);
+        const latestPositions = {};
+
+        tracks.forEach(track => {
+            const vesselId = `${track.sig_src_cd}_${track.target_id}`;
+            const path = Utils.parseLineStringM(track.track_geom);
+
+            if (path.length > 0) {
+                if (!latestPositions[vesselId] ||
+                    new Date(track.time_bucket) > new Date(latestPositions[vesselId].time)) {
+                    latestPositions[vesselId] = {
+                        position: path[path.length - 1],
+                        sig_src_cd: track.sig_src_cd,
+                        target_id: track.target_id,
+                        time: track.time_bucket,
+                        speed: parseFloat(track.avg_speed) || 0
+                    };
+                }
+            }
+        });
+
+        return Object.values(latestPositions);
+    }
+
+    async loadAreaTracks(type, id, period) {
+        const tracks = await $.get(`/api/v1/tracks/${type}/${id}?minutes=${period}`);
+        const vesselTracks = {};
+
+        tracks.forEach(track => {
+            const vesselId = `${track.sig_src_cd}_${track.target_id}`;
+            if (!vesselTracks[vesselId]) {
+                vesselTracks[vesselId] = {
+                    vessel_id: vesselId,
+                    tracks: [],
+                    total_distance: 0,
+                    avg_speeds: []
+                };
+            }
+            vesselTracks[vesselId].tracks.push(track);
+            vesselTracks[vesselId].total_distance += parseFloat(track.distance_nm) || 0;
+            vesselTracks[vesselId].avg_speeds.push(parseFloat(track.avg_speed) || 0);
+        });
+
+        const processedTracks = [];
+        Object.values(vesselTracks).forEach(vessel => {
+            vessel.tracks.sort((a, b) => new Date(a.time_bucket) - new Date(b.time_bucket));
+
+            const allPoints = [];
+            vessel.tracks.forEach(track => {
+                const points = Utils.parseLineStringM(track.track_geom);
+                allPoints.push(...points);
+            });
+
+            if (allPoints.length > 0) {
+                const avgSpeed = vessel.avg_speeds.reduce((a, b) => a + b, 0) / vessel.avg_speeds.length;
+                processedTracks.push({
+                    path: allPoints,
+                    vessel_id: vessel.vessel_id,
+                    distance: vessel.total_distance,
+                    avg_speed: avgSpeed,
+                    selected: false
+                });
+            }
+        });
+
+        return processedTracks;
+    }
+
+    processTracks(tracks, type, areaId) {
+        tracks.forEach(track => {
+            const path = Utils.parseLineStringM(track.track_geom);
+            if (path.length > 0) {
+                this.allTracks.push({
+                    path: path,
+                    vessel_id: `${track.sig_src_cd}_${track.target_id}`,
+                    distance: parseFloat(track.distance_nm) || 0,
+                    avg_speed: parseFloat(track.avg_speed) || 0,
+                    time_bucket: track.time_bucket,
+                    type: type,
+                    area_id: areaId
+                });
+            }
+        });
+    }
+
+    applyFilters(filters) {
+        this.filteredTracks = this.allTracks.filter(track =>
+            track.avg_speed >= filters.minSpeed &&
+            track.avg_speed <= filters.maxSpeed &&
+            track.distance >= filters.minDist &&
+            track.distance <= filters.maxDist
+        );
+    }
+
+    resetFilters() {
+        this.filteredTracks = [...this.allTracks];
+    }
+
+    clearTracks() {
+        this.allTracks = [];
+        this.filteredTracks = [];
+    }
+
+    clearAllTracks() {
+        this.allTracks = [];
+        this.filteredTracks = [];
+    }
+
+    setCurrentArea(type, id) {
+        this.currentArea = { type, id };
+    }
+
+    getCurrentArea() {
+        return this.currentArea;
+    }
+
+    getFilteredTracks() {
+        return this.filteredTracks;
+    }
+}
+
+// =====================================================
+// Vessel Manager Class
+// =====================================================
+class VesselManager {
+    constructor() {
+        this.vesselList = [];
+        this.selectedVessels = new Set();
+        this.tracks = [];
+        this.currentArea = null;
+    }
+
+    async loadVesselList(type, id, timeRange) {
+        this.currentArea = { type, id };
+
+        const tracks = await $.get(`/api/v1/tracks/${type}/${id}?minutes=${timeRange}`);
+
+        const vessels = tracks.map(t => ({
+            id: `${t.sig_src_cd}_${t.target_id}`,
+            sig_src_cd: t.sig_src_cd,
+            target_id: t.target_id,
+            distance: parseFloat(t.distance_nm) || 0,
+            avg_speed: parseFloat(t.avg_speed) || 0,
+            type: type,
+            area_id: id,
+            track_geom: t.track_geom,
+            time_bucket: t.time_bucket
+        }));
+
+        const uniqueVessels = {};
+        vessels.forEach(v => {
+            if (!uniqueVessels[v.id] || uniqueVessels[v.id].distance < v.distance) {
+                uniqueVessels[v.id] = v;
+            }
+        });
+
+        this.vesselList = Object.values(uniqueVessels);
+        return this.vesselList;
+    }
+
+    async loadSelectedTracks(period) {
+        this.tracks = [];
+
+        const trackPromises = [];
+
+        for (const vessel of this.vesselList) {
+            if (this.selectedVessels.has(vessel.id)) {
+                trackPromises.push(
+                    $.get(`/api/v1/tracks/${vessel.type}/${vessel.area_id}?minutes=${period}`)
+                        .then(tracks => {
+                            const vesselTracks = tracks.filter(t =>
+                                `${t.sig_src_cd}_${t.target_id}` === vessel.id
+                            );
+
+                            const allPoints = [];
+                            vesselTracks.forEach(track => {
+                                const points = Utils.parseLineStringM(track.track_geom);
+                                allPoints.push(...points);
+                            });
+
+                            if (allPoints.length > 0) {
+                                this.tracks.push({
+                                    path: allPoints,
+                                    vessel_id: vessel.id,
+                                    distance: vesselTracks.reduce((sum, t) => sum + (parseFloat(t.distance_nm) || 0), 0),
+                                    avg_speed: vesselTracks.reduce((sum, t) => sum + (parseFloat(t.avg_speed) || 0), 0) / vesselTracks.length,
+                                    selected: true
+                                });
+                            }
+                        })
+                );
+            }
+        }
+
+        await Promise.all(trackPromises);
+        return this.tracks;
+    }
+
+    sortAndRender() {
+        const sortBy = $('#sortBy').val();
+        const sortOrder = $('#sortOrder').val();
+
+        this.vesselList.sort((a, b) => {
+            let compareValue = 0;
+
+            switch (sortBy) {
+                case 'id':
+                    compareValue = a.id.localeCompare(b.id);
+                    break;
+                case 'speed':
+                    compareValue = a.avg_speed - b.avg_speed;
+                    break;
+                case 'distance':
+                    compareValue = a.distance - b.distance;
+                    break;
+            }
+
+            return sortOrder === 'asc' ? compareValue : -compareValue;
+        });
+
+        this.render();
+    }
+
+    render() {
+        const content = $('#vesselListContent');
+
+        if (this.vesselList.length === 0) {
+            content.html('<div class="text-muted">No vessels found in this area</div>');
+            return;
+        }
+
+        let html = `<div class="mb-2">Found ${this.vesselList.length} vessels</div>`;
+
+        this.vesselList.forEach(v => {
+            const isSelected = this.selectedVessels.has(v.id);
+            html += `
+                <div class="vessel-item ${isSelected ? 'selected' : ''}" data-vessel-id="${v.id}">
+                    <input type="checkbox" class="vessel-checkbox"
+                           data-vessel-id="${v.id}"
+                           ${isSelected ? 'checked' : ''}>
+                    <div class="vessel-info">
+                        <strong>${v.id}</strong><br>
+                        <small>
+                            Distance: ${v.distance.toFixed(2)} nm |
+                            Avg Speed: ${v.avg_speed.toFixed(1)} kts
+                        </small>
+                    </div>
+                </div>
+            `;
+        });
+
+        content.html(html);
+
+        $('.vessel-checkbox').off('change').on('change', function (e) {
+            e.stopPropagation();
+            const vesselId = $(this).data('vessel-id');
+            GISApp.vesselManager.toggleSelection(vesselId);
+        });
+
+        $('.vessel-item').off('click').on('click', function (e) {
+            if (!$(e.target).is('.vessel-checkbox')) {
+                const checkbox = $(this).find('.vessel-checkbox');
+                checkbox.prop('checked', !checkbox.prop('checked'));
+                const vesselId = $(this).data('vessel-id');
+                GISApp.vesselManager.toggleSelection(vesselId);
+            }
+        });
+
+        this.updateSelectedCount();
+    }
+
+    toggleSelection(vesselId) {
+        if (this.selectedVessels.has(vesselId)) {
+            this.selectedVessels.delete(vesselId);
+        } else {
+            this.selectedVessels.add(vesselId);
+        }
+
+        const vesselItem = $(`.vessel-item[data-vessel-id="${vesselId}"]`);
+        const checkbox = vesselItem.find('.vessel-checkbox');
+
+        if (this.selectedVessels.has(vesselId)) {
+            vesselItem.addClass('selected');
+            checkbox.prop('checked', true);
+        } else {
+            vesselItem.removeClass('selected');
+            checkbox.prop('checked', false);
+        }
+
+        this.updateSelectedCount();
+    }
+
+    selectAll() {
+        this.vesselList.forEach(v => this.selectedVessels.add(v.id));
+        this.render();
+    }
+
+    deselectAll() {
+        this.selectedVessels.clear();
+        this.render();
+    }
+
+    clearSelection() {
+        this.selectedVessels.clear();
+        this.tracks = [];
+        this.updateSelectedCount();
+    }
+
+    applyFilters(filters) {
+        const originalList = [...this.vesselList];
+        this.vesselList = originalList.filter(v =>
+            v.avg_speed >= filters.minSpeed &&
+            v.avg_speed <= filters.maxSpeed &&
+            v.distance >= filters.minDist &&
+            v.distance <= filters.maxDist
+        );
+        this.render();
+    }
+
+    resetFilters() {
+        if (this.currentArea) {
+            this.loadVesselList(
+                this.currentArea.type,
+                this.currentArea.id,
+                $('#gisTimeRange').val()
+            ).then(() => this.sortAndRender());
+        }
+    }
+
+    updateSelectedCount() {
+        const count = this.selectedVessels.size;
+        const countElement = $('#selectedCount');
+
+        if (count > 0) {
+            countElement.text(count).show();
+        } else {
+            countElement.hide();
+        }
+    }
+
+    getSelectedVessels() {
+        return this.selectedVessels;
+    }
+
+    getTracks() {
+        return this.tracks;
+    }
+}
+
+// =====================================================
+// Layer Manager Class
+// =====================================================
+class LayerManager {
+    constructor(deckOverlay) {
+        this.deckOverlay = deckOverlay;
+        this.layers = new Map();
+        this.hexagonManager = null;
+    }
+
+    updateAllLayers(dataManager) {
+        const layers = [];
+        const layerType = $('#gisLayerType').val();
+
+        if ((layerType === 'haegu' || layerType === 'both') && dataManager.haegus.length > 0) {
+            layers.push(this.createHaeguLayer(dataManager.haegus, dataManager.haeguStats));
+        }
+
+        if ((layerType === 'area' || layerType === 'both') && dataManager.areas.length > 0) {
+            layers.push(this.createAreaLayer(dataManager.areas, dataManager.areaStats));
+        }
+
+        if (this.layers.has('track-layer')) {
+            layers.push(this.layers.get('track-layer'));
+        }
+        if (this.layers.has('all-tracks-layer')) {
+            layers.push(this.layers.get('all-tracks-layer'));
+        }
+        if (this.layers.has('position-layer')) {
+            layers.push(this.layers.get('position-layer'));
+        }
+
+        this.deckOverlay.setProps({ layers });
+    }
+
+    createHaeguLayer(haegus, stats) {
+        const layer = new deck.GeoJsonLayer({
+            id: 'haegu-layer',
+            data: {
+                type: 'FeatureCollection',
+                features: haegus.map(haegu => ({
+                    type: 'Feature',
+                    properties: {
+                        haegu_no: haegu.haegu_no,
+                        vessel_count: stats?.[haegu.haegu_no]?.vessel_count || 0,
+                        total_distance: stats?.[haegu.haegu_no]?.total_distance || 0
+                    },
+                    geometry: JSON.parse(haegu.geom_json)
+                }))
+            },
+            filled: true,
+            stroked: true,
+            getFillColor: d => Utils.getVesselCountColor(d.properties.vessel_count),
+            getLineColor: [0, 100, 200, 255],
+            getLineWidth: 2,
+            lineWidthMinPixels: 1,
+            pickable: true,
+            autoHighlight: true,
+            highlightColor: [255, 255, 0, 100],
+            onClick: (info) => {
+                if (info.object) {
+                    GISApp.showAreaDetails('haegu', info.object.properties);
+                }
+                return true;
+            }
+        });
+
+        this.layers.set('haegu-layer', layer);
+        return layer;
+    }
+
+    createAreaLayer(areas, stats) {
+        const layer = new deck.GeoJsonLayer({
+            id: 'area-layer',
+            data: {
+                type: 'FeatureCollection',
+                features: areas.map(area => ({
+                    type: 'Feature',
+                    properties: {
+                        area_id: area.area_id,
+                        area_name: area.area_name,
+                        vessel_count: stats?.[area.area_id]?.vessel_count || 0,
+                        total_distance: stats?.[area.area_id]?.total_distance || 0
+                    },
+                    geometry: JSON.parse(area.geom_json)
+                }))
+            },
+            filled: true,
+            stroked: true,
+            getFillColor: d => Utils.getVesselCountColor(d.properties.vessel_count),
+            getLineColor: [200, 100, 0, 255],
+            getLineWidth: 3,
+            lineWidthMinPixels: 2,
+            pickable: true,
+            autoHighlight: true,
+            highlightColor: [255, 255, 0, 100],
+            onClick: (info) => {
+                if (info.object) {
+                    GISApp.showAreaDetails('area', info.object.properties);
+                }
+                return true;
+            }
+        });
+
+        this.layers.set('area-layer', layer);
+        return layer;
+    }
+
+    updateTrackLayer(tracks) {
+        if (!tracks || tracks.length === 0) {
+            this.layers.delete('track-layer');
+        } else {
+            const layer = new deck.PathLayer({
+                id: 'track-layer',
+                data: tracks,
+                getPath: d => d.path,
+                getColor: d => d.selected ? [0, 128, 255, 255] : [0, 255, 0, 255],
+                getWidth: d => d.selected ? 4 : 3,
+                pickable: true,
+                widthMinPixels: 2,
+                widthMaxPixels: 10,
+                capRounded: true,
+                jointRounded: true,
+                billboard: false
+            });
+
+            this.layers.set('track-layer', layer);
+        }
+
+        this.updateDeckLayers();
+    }
+
+    updateAllTracksLayer(tracks) {
+        if (!tracks || tracks.length === 0) {
+            this.layers.delete('all-tracks-layer');
+        } else {
+            const layer = new deck.PathLayer({
+                id: 'all-tracks-layer',
+                data: tracks,
+                getPath: d => d.path,
+                getColor: d => {
+                    if (d.avg_speed > 20) return [255, 0, 0, 200];
+                    if (d.avg_speed > 10) return [255, 165, 0, 200];
+                    return [0, 128, 255, 200];
+                },
+                getWidth: 2,
+                pickable: true,
+                widthMinPixels: 1,
+                widthMaxPixels: 5,
+                capRounded: true,
+                jointRounded: true,
+                billboard: false
+            });
+
+            this.layers.set('all-tracks-layer', layer);
+        }
+
+        this.updateDeckLayers();
+    }
+
+    updatePositionLayer(positions) {
+        if (!positions || positions.length === 0) {
+            this.layers.delete('position-layer');
+        } else {
+            const layer = new deck.ScatterplotLayer({
+                id: 'position-layer',
+                data: positions,
+                getPosition: d => d.position,
+                getRadius: 4,
+                radiusMinPixels: 3,
+                radiusMaxPixels: 8,
+                getFillColor: [255, 0, 0, 255],
+                getLineColor: [255, 255, 255, 255],
+                lineWidthMinPixels: 1,
+                pickable: true
+            });
+
+            this.layers.set('position-layer', layer);
+        }
+
+        this.updateDeckLayers();
+    }
+
+    updateDeckLayers() {
+        this.deckOverlay.setProps({ layers: Array.from(this.layers.values()) });
+    }
+
+    /**
+     * Create and update Hexagon Layer for vessel density visualization
+     */
+    updateHexagonLayer(positions, hexagonManager) {
+        this.hexagonManager = hexagonManager;
+
+        this.layers.delete('haegu-layer');
+        this.layers.delete('area-layer');
+
+        if (!positions || positions.length === 0) {
+            console.warn('No positions for hexagon layer');
+            this.layers.delete('hexagon-layer');
+            this.updateDeckLayers();
+            return;
+        }
+
+        const COLOR_RANGE = [
+            [1, 152, 189],
+            [73, 227, 206],
+            [216, 254, 181],
+            [254, 237, 177],
+            [254, 173, 84],
+            [209, 55, 78]
+        ];
+
+        const hexagonLayer = new deck.HexagonLayer({
+            id: 'hexagon-layer',
+            data: positions,
+            getPosition: d => d.position,
+
+            radius: 5000,
+            coverage: 0.9,
+
+            extruded: true,
+            elevationScale: 100,
+            elevationRange: [0, 3000],
+
+            colorRange: COLOR_RANGE,
+            colorAggregation: 'SUM',
+
+            // Use CPU aggregation to preserve original data in points
+            gpuAggregation: false,
+
+            pickable: true,
+            autoHighlight: true,
+
+            material: {
+                ambient: 0.64,
+                diffuse: 0.6,
+                shininess: 32,
+                specularColor: [51, 51, 51]
+            },
+
+            transitions: {
+                elevationScale: 500
+            },
+
+            // Click handler for hexagon
+            onClick: (info) => {
+                if (info.object) {
+                    GISApp.handleHexagonClick(info);
+                }
+                return true;
+            },
+
+            // Update stats when data changes
+            onSetColorDomain: (domain) => {
+                if (domain && domain.length > 1) {
+                    hexagonManager.updateStats(domain[1]);
+                }
+            }
+        });
+
+        this.layers.set('hexagon-layer', hexagonLayer);
+        this.updateDeckLayers();
+
+        console.log(`Hexagon layer created with ${positions.length} points`);
+    }
+
+    removeHexagonLayer() {
+        this.layers.delete('hexagon-layer');
+    }
+}
+
+// =====================================================
+// Sequential Passage Manager Class
+// =====================================================
+class SequentialPassageManager {
+    constructor() {
+        this.zones = [];
+        this.maxZones = 3;
+        this.results = null;
+    }
+
+    addZone(zoneId) {
+        if (!zoneId) return false;
+
+        if (this.zones.length >= this.maxZones) {
+            alert(`Maximum ${this.maxZones} zones allowed`);
+            return false;
+        }
+
+        if (this.zones.includes(zoneId)) {
+            alert('Zone already added');
+            return false;
+        }
+
+        this.zones.push(zoneId);
+        this.renderZones();
+        console.log('Added zone:', zoneId, 'Total zones:', this.zones);
+        return true;
+    }
+
+    removeZone(index) {
+        this.zones.splice(index, 1);
+        this.renderZones();
+    }
+
+    renderZones() {
+        const container = $('#selectedZones');
+
+        if (this.zones.length === 0) {
+            container.html('<small class="text-muted">No zones selected</small>');
+            return;
+        }
+
+        let html = '';
+        this.zones.forEach((zone, index) => {
+            html += `
+                <span class="zone-tag">
+                    ${zone}
+                    <span class="remove-zone" onclick="GISApp.sequentialManager.removeZone(${index})">
+                        <i class="bi bi-x"></i>
+                    </span>
+                </span>
+            `;
+        });
+
+        container.html(html);
+    }
+
+    async search(mode, type, startTime, endTime, zones) {
+        const endpoint = mode === 'sequential' ?
+            '/api/v1/passages/sequential' :
+            '/api/v1/passages/all-zones';
+
+        const formattedStartTime = startTime.includes('T') ?
+            startTime + ':00' : startTime;
+        const formattedEndTime = endTime.includes('T') ?
+            endTime + ':00' : endTime;
+
+        const response = await $.ajax({
+            url: endpoint,
+            method: 'POST',
+            contentType: 'application/json',
+            data: JSON.stringify({
+                type: type,
+                zoneIds: zones,
+                startTime: formattedStartTime,
+                endTime: formattedEndTime
+            })
+        });
+
+        return response;
+    }
+
+    getZones() {
+        return this.zones;
+    }
+
+    clearZones() {
+        this.zones = [];
+        this.renderZones();
+    }
+
+    setResults(results) {
+        this.results = results;
+    }
+
+    getResults() {
+        return this.results;
+    }
+}
+
+// =====================================================
+// Utility Functions
+// =====================================================
+class Utils {
+    static parseLineStringM(wkt) {
+        if (!wkt) return [];
+
+        const matches = wkt.match(/LINESTRING M\s*\((.*)\)/);
+        if (!matches) return [];
+
+        try {
+            const coords = matches[1].split(',').map(coord => {
+                const parts = coord.trim().split(/\s+/);
+                const lon = parseFloat(parts[0]);
+                const lat = parseFloat(parts[1]);
+
+                if (isNaN(lon) || isNaN(lat)) return null;
+
+                return [lon, lat];
+            }).filter(coord => coord !== null);
+
+            return coords;
+        } catch (error) {
+            console.error('Error parsing LineStringM:', error);
+            return [];
+        }
+    }
+
+    static getVesselCountColor(count) {
+        if (count >= 200) return [255, 69, 0, 150];
+        if (count >= 100) return [255, 165, 0, 150];
+        if (count >= 50) return [255, 215, 0, 150];
+        if (count >= 10) return [144, 238, 144, 150];
+        if (count > 0) return [224, 224, 224, 150];
+        return [224, 224, 224, 50];
+    }
+}
+
+// =====================================================
+// Initialize Application
+// =====================================================
+let GISApp;
+$(document).ready(function () {
+    GISApp = new GISMonitoringApp();
+});
+
diff --git a/src/main/resources/static/v2/pages/chunked-streaming.html b/src/main/resources/static/v2/pages/chunked-streaming.html
index c942f1a..f8d0530 100644
--- a/src/main/resources/static/v2/pages/chunked-streaming.html
+++ b/src/main/resources/static/v2/pages/chunked-streaming.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Chunked GIS Streaming v2.0 - Vessel Animation</title>
+    <title>청크 GIS 스트리밍 v2.0 - 선박 애니메이션</title>
     
     <!-- 외부 라이브러리 CSS (폐쇄망 대응) -->
     <link href="/libs/css/maplibre-gl.css" rel="stylesheet">
@@ -20,7 +20,7 @@
     <!-- 제어 패널 -->
     <div class="control-panel">
         <h5 class="mb-3">
-            <i class="bi bi-globe2"></i> Chunked GIS v2.0 + Animation
+            <i class="bi bi-globe2"></i> 청크 GIS v2.0 + 애니메이션
         </h5>
         
         <!-- 연결 제어 -->
@@ -232,7 +232,7 @@
     <div class="log-panel">
         <div class="d-flex justify-content-between align-items-center mb-2">
             <h6 class="mb-0"><i class="bi bi-terminal"></i> 로그</h6>
-            <button class="btn btn-sm btn-outline-secondary" onclick="clearLog()">Clear</button>
+            <button class="btn btn-sm btn-outline-secondary" onclick="clearLog()">초기화</button>
         </div>
         <div id="logContainer"></div>
     </div>
diff --git a/src/main/resources/static/v2/pages/gis-monitoring.html b/src/main/resources/static/v2/pages/gis-monitoring.html
index 2703458..0456bc2 100644
--- a/src/main/resources/static/v2/pages/gis-monitoring.html
+++ b/src/main/resources/static/v2/pages/gis-monitoring.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>GIS Monitoring v2.0 - Vessel Batch</title>
+    <title>GIS 모니터링 v2.0 - 선박 항적</title>
     
     <!-- 외부 라이브러리 CSS (폐쇄망 대응) -->
     <link href="/libs/css/bootstrap.min.css" rel="stylesheet">
@@ -19,7 +19,7 @@
         <!-- 메인 컨트롤 패널 -->
         <div class="gis-control-panel" id="controlPanel">
             <div class="panel-header">
-                <h5 class="mb-0">GIS Monitoring v2.0</h5>
+                <h5 class="mb-0">GIS 모니터링 v2.0</h5>
                 <span class="panel-toggle" id="panelToggle" title="패널 접기/펼치기">
                     <i class="bi bi-chevron-left"></i>
                 </span>
@@ -62,7 +62,7 @@
                 </button>
                 
                 <button class="btn btn-success btn-sm w-100" id="sequentialBtn">
-                    <i class="bi bi-diagram-3"></i> Sequential Passage
+                    <i class="bi bi-diagram-3"></i> 순차 통과 분석
                 </button>
                 
                 <!-- 선박 목록 섹션 -->
@@ -180,7 +180,7 @@
         <!-- Sequential Passage 패널 -->
         <div class="sequential-panel" id="sequentialPanel">
             <div class="d-flex justify-content-between align-items-center mb-3">
-                <h5 class="mb-0">Sequential Passage 분석</h5>
+                <h5 class="mb-0">순차 통과 분석</h5>
                 <button class="btn btn-sm btn-link" id="closeSequentialBtn">
                     <i class="bi bi-x-lg"></i>
                 </button>
@@ -279,7 +279,7 @@
     <!-- 컨텍스트 메뉴 -->
     <div class="context-menu" id="contextMenu">
         <div class="context-menu-item" id="addToSequential">
-            <i class="bi bi-plus-circle"></i> Sequential에 추가
+            <i class="bi bi-plus-circle"></i> 순차 통과에 추가
         </div>
         <div class="context-menu-item" id="viewAreaDetails">
             <i class="bi bi-info-circle"></i> 상세 정보 보기
diff --git a/src/main/resources/static/websocket/chunked-streaming-gis-animated.html b/src/main/resources/static/websocket/chunked-streaming-gis-animated.html
index 9665185..9c9b316 100644
--- a/src/main/resources/static/websocket/chunked-streaming-gis-animated.html
+++ b/src/main/resources/static/websocket/chunked-streaming-gis-animated.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Chunked GIS Streaming with Vessel Animation</title>
+    <title>청크 GIS 스트리밍 - 선박 애니메이션</title>
     
     <!-- CSS -->
     <link href="/libs/css/maplibre-gl.css" rel="stylesheet">
@@ -216,7 +216,7 @@
     <!-- 제어 패널 -->
     <div class="control-panel">
         <h5 class="mb-3">
-            <i class="bi bi-globe2"></i> Chunked GIS + Animation
+            <i class="bi bi-globe2"></i> 청크 GIS + 애니메이션
         </h5>
         
         <!-- 연결 제어 -->
@@ -428,7 +428,7 @@
     <div class="log-panel">
         <div class="d-flex justify-content-between align-items-center mb-2">
             <h6 class="mb-0"><i class="bi bi-terminal"></i> 로그</h6>
-            <button class="btn btn-sm btn-outline-secondary" onclick="clearLog()">Clear</button>
+            <button class="btn btn-sm btn-outline-secondary" onclick="clearLog()">초기화</button>
         </div>
         <div id="logContainer"></div>
     </div>
diff --git a/src/test/java/gc/mda/signal_batch/websocket/WebSocketLoadTest.java b/src/test/java/gc/mda/signal_batch/websocket/WebSocketLoadTest.java
index babd5a7..331a7c4 100644
--- a/src/test/java/gc/mda/signal_batch/websocket/WebSocketLoadTest.java
+++ b/src/test/java/gc/mda/signal_batch/websocket/WebSocketLoadTest.java
@@ -230,17 +230,19 @@ public class WebSocketLoadTest {
             .mapToLong(QueryMetrics::getTotalTracks)
             .summaryStatistics();
         
-        log.info("실행 시간: 평균 {:.2f}초, 최소 {:.2f}초, 최대 {:.2f}초",
-                durationStats.getAverage(), durationStats.getMin(), durationStats.getMax());
-        
+        log.info("실행 시간: 평균 {}초, 최소 {}초, 최대 {}초",
+                String.format("%.2f", durationStats.getAverage()),
+                String.format("%.2f", durationStats.getMin()),
+                String.format("%.2f", durationStats.getMax()));
+
         log.info("청크 수: 평균 {}, 총 {}",
                 chunkStats.getAverage(), chunkStats.getSum());
-        
+
         log.info("트랙 수: 평균 {}, 총 {}",
                 trackStats.getAverage(), trackStats.getSum());
-        
+
         double totalThroughput = trackStats.getSum() / durationStats.getSum();
-        log.info("전체 처리량: {:.2f} tracks/second", totalThroughput);
+        log.info("전체 처리량: {} tracks/second", String.format("%.2f", totalThroughput));
     }
     
     // Inner classes