fix issues

docs/02_components/10_factor_graph_optimizer/factor_graph_optimizer_spec.md

@@ -8,64 +8,67 @@
 
 ```python
 class IFactorGraphOptimizer(ABC):
+    # All methods take flight_id to support concurrent flights
+    # F10 maintains Dict[str, FactorGraph] keyed by flight_id internally
+    
     @abstractmethod
-    def add_relative_factor(self, frame_i: int, frame_j: int, relative_pose: RelativePose, covariance: np.ndarray) -> bool:
+    def add_relative_factor(self, flight_id: str, frame_i: int, frame_j: int, relative_pose: RelativePose, covariance: np.ndarray) -> bool:
         pass
     
     @abstractmethod
-    def add_absolute_factor(self, frame_id: int, gps: GPSPoint, covariance: np.ndarray, is_user_anchor: bool) -> bool:
+    def add_absolute_factor(self, flight_id: str, frame_id: int, gps: GPSPoint, covariance: np.ndarray, is_user_anchor: bool) -> bool:
         pass
     
     @abstractmethod
-    def add_altitude_prior(self, frame_id: int, altitude: float, covariance: float) -> bool:
+    def add_altitude_prior(self, flight_id: str, frame_id: int, altitude: float, covariance: float) -> bool:
         pass
     
     @abstractmethod
-    def optimize(self, iterations: int) -> OptimizationResult:
+    def optimize(self, flight_id: str, iterations: int) -> OptimizationResult:
         pass
     
     @abstractmethod
-    def get_trajectory(self) -> Dict[int, Pose]:
+    def get_trajectory(self, flight_id: str) -> Dict[int, Pose]:
         pass
     
     @abstractmethod
-    def get_marginal_covariance(self, frame_id: int) -> np.ndarray:
+    def get_marginal_covariance(self, flight_id: str, frame_id: int) -> np.ndarray:
+        pass
+    
+    # Chunk operations - F10 only manages factor graph subgraphs
+    # F12 owns chunk metadata (status, is_active, etc.)
+    @abstractmethod
+    def create_chunk_subgraph(self, flight_id: str, chunk_id: str, start_frame_id: int) -> bool:
         pass
     
     @abstractmethod
-    def create_new_chunk(self, chunk_id: str, start_frame_id: int) -> ChunkHandle:
+    def add_relative_factor_to_chunk(self, flight_id: str, chunk_id: str, frame_i: int, frame_j: int, relative_pose: RelativePose, covariance: np.ndarray) -> bool:
         pass
     
     @abstractmethod
-    def get_chunk_for_frame(self, frame_id: int) -> Optional[ChunkHandle]:
+    def add_chunk_anchor(self, flight_id: str, chunk_id: str, frame_id: int, gps: GPSPoint, covariance: np.ndarray) -> bool:
         pass
     
     @abstractmethod
-    def add_relative_factor_to_chunk(self, chunk_id: str, frame_i: int, frame_j: int, relative_pose: RelativePose, covariance: np.ndarray) -> bool:
+    def merge_chunk_subgraphs(self, flight_id: str, source_chunk_id: str, target_chunk_id: str, transform: Sim3Transform) -> bool:
+        """Merges source_chunk INTO target_chunk. Source chunk subgraph is merged into target."""
         pass
     
     @abstractmethod
-    def add_chunk_anchor(self, chunk_id: str, frame_id: int, gps: GPSPoint, covariance: np.ndarray) -> bool:
+    def get_chunk_trajectory(self, flight_id: str, chunk_id: str) -> Dict[int, Pose]:
         pass
     
     @abstractmethod
-    def merge_chunks(self, chunk_id_1: str, chunk_id_2: str, transform: Sim3Transform) -> bool:
+    def optimize_chunk(self, flight_id: str, chunk_id: str, iterations: int) -> OptimizationResult:
         pass
     
     @abstractmethod
-    def get_chunk_trajectory(self, chunk_id: str) -> Dict[int, Pose]:
+    def optimize_global(self, flight_id: str, iterations: int) -> OptimizationResult:
         pass
     
     @abstractmethod
-    def get_all_chunks(self) -> List[ChunkHandle]:
-        pass
-    
-    @abstractmethod
-    def optimize_chunk(self, chunk_id: str, iterations: int) -> OptimizationResult:
-        pass
-    
-    @abstractmethod
-    def optimize_global(self, iterations: int) -> OptimizationResult:
+    def delete_flight_graph(self, flight_id: str) -> bool:
+        """Cleanup factor graph when flight is deleted."""
         pass
 ```
 
@@ -84,16 +87,20 @@ class IFactorGraphOptimizer(ABC):
 ### Chunk Responsibility Clarification
 
 **F10 provides low-level factor graph operations only**:
-- `create_new_chunk()`: Creates subgraph in factor graph
+- `create_chunk_subgraph()`: Creates subgraph in factor graph (returns bool, not ChunkHandle)
 - `add_relative_factor_to_chunk()`: Adds factors to chunk's subgraph
-- `add_chunk_anchor()`: Adds GPS anchor to chunk
-- `merge_chunks()`: Applies Sim(3) transform and merges subgraphs
+- `add_chunk_anchor()`: Adds GPS anchor to chunk's subgraph
+- `merge_chunk_subgraphs()`: Applies Sim(3) transform and merges subgraphs
 - `optimize_chunk()`, `optimize_global()`: Runs optimization
 
-**F12 is the source of truth for chunk state** (see F12 spec):
-- Chunk lifecycle management (active, anchored, merged status)
+**F10 does NOT own chunk metadata** - only factor graph data structures.
+
+**F12 is the source of truth for ALL chunk state** (see F12 spec):
+- ChunkHandle with all metadata (is_active, has_anchor, matching_status)
+- Chunk lifecycle management
 - Chunk readiness determination
 - High-level chunk queries
+- F12 calls F10 for factor graph operations
 
 **F11 coordinates recovery** (see F11 spec):
 - Triggers chunk creation via F12
@@ -155,16 +162,19 @@ F07 returns unit translation vectors due to monocular scale ambiguity. F10 resol
 **Explicit Flow**:
 ```python
 # In add_relative_factor():
-# altitude comes from F05 Image Input Pipeline (extracted from EXIF metadata)
+# altitude comes from F17 Configuration Manager (predefined operational altitude)
 # focal_length, sensor_width from F17 Configuration Manager
-gsd = H02.compute_gsd(altitude, focal_length, sensor_width, image_width)
+config = F17.get_flight_config(flight_id)
+altitude = config.altitude  # Predefined altitude, NOT from EXIF
+gsd = H02.compute_gsd(altitude, config.camera_params.focal_length, 
+                       config.camera_params.sensor_width, 
+                       config.camera_params.resolution_width)
 expected_displacement = frame_spacing * gsd  # ~100m typical at 300m altitude
 scaled_translation = relative_pose.translation * expected_displacement
 # Add scaled_translation to factor graph
 ```
 
-**Note**: Altitude is passed through the processing chain:
-- F05 extracts altitude from EXIF → F02 includes in FrameData → F10 receives with add_relative_factor()
+**Note**: Altitude comes from F17 Configuration Manager (predefined operational altitude), NOT from EXIF metadata. The problem statement specifies images don't have GPS metadata.
 
 **Output**:
 ```python