fix: gate active missions against draft voyages

Author: rupurt

crates/keel-cli/src/cli/commands/management/voyage/new.rs

@@ -6,6 +6,7 @@ use std::path::Path;
 use anyhow::{Context, Result, anyhow};
 use chrono::Local;
 
+use keel::domain::model::MissionStatus;
 use keel::infrastructure::duplicate_ids::{self, DuplicateEntity};
 use keel::infrastructure::frontmatter_mutation::Mutation;
 use keel::infrastructure::loader::load_board;
@@ -42,7 +43,17 @@ fn new_voyage(board_dir: &Path, name: &str, epic_id: &str, goal: &str) -> Result
     }
 
     // Verify epic exists
-    board.require_epic(epic_id)?;
+    let epic = board.require_epic(epic_id)?;
+    if let Some(mission_id) = epic.frontmatter.mission.as_deref()
+        && let Some(mission) = board.missions.get(mission_id)
+        && mission.status() == MissionStatus::Active
+    {
+        return Err(anyhow!(
+            "Cannot create draft voyage under active mission {} via epic {}. Plan voyage work before mission activation or pause the mission before adding draft voyage scope.",
+            mission.id(),
+            epic_id,
+        ));
+    }
 
     // Find next voyage number for this epic
     let next_num = find_next_voyage_num(&board, epic_id);
@@ -153,7 +164,7 @@ fn find_next_voyage_num(board: &keel::domain::model::Board, epic_id: &str) -> u3
 mod tests {
     use super::*;
     use keel::infrastructure::validation::{CheckId, structural};
-    use keel::test_helpers::{TestBoardBuilder, TestEpic, TestVoyage};
+    use keel::test_helpers::{TestBoardBuilder, TestEpic, TestMission, TestVoyage};
     use regex::Regex;
 
     #[test]
@@ -215,6 +226,21 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_new_voyage_rejects_active_mission_epic() {
+        let temp = TestBoardBuilder::new()
+            .mission(TestMission::new("M1").status("active"))
+            .epic(TestEpic::new("test-epic").mission("M1"))
+            .build();
+
+        let err = new_voyage(temp.path(), "New Voyage", "test-epic", "My goal")
+            .unwrap_err()
+            .to_string();
+
+        assert!(err.contains("active mission M1"), "{err}");
+        assert!(err.contains("draft voyage"), "{err}");
+    }
+
     #[test]
     fn test_find_next_voyage_num() {
         let temp = TestBoardBuilder::new()

crates/keel-core/src/application/mission_lifecycle.rs

@@ -44,6 +44,14 @@ impl MissionLifecycleService {
     }
 
     pub fn resume(board_dir: &Path, id: &str) -> Result<()> {
+        let board = load_board(board_dir)?;
+        let mission = board.require_mission(id)?;
+
+        let problems = evaluate_mission_transition(&board, mission, MissionTransition::Resume);
+        if !problems.is_empty() {
+            return Err(anyhow!(format_gate_error("mission", "resume", &problems)));
+        }
+
         execute(board_dir, id, &mission_transitions::RESUME)?;
         println!("Resumed mission: {}", id);
         Ok(())
@@ -494,6 +502,43 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_mission_activate_fails_with_draft_voyage() {
+        let temp = TestBoardBuilder::new()
+            .mission(
+                TestMission::new("M1")
+                    .title("Mission One")
+                    .status("defining"),
+            )
+            .epic(TestEpic::new("E1").mission("M1"))
+            .voyage(TestVoyage::new("V1", "E1").status("draft"))
+            .build();
+
+        let charter_path = temp.path().join("missions/M1/CHARTER.md");
+        fs::write(charter_path, authored_charter("E1")).unwrap();
+
+        let res = MissionLifecycleService::activate(temp.path(), "M1");
+        assert!(res.is_err());
+        let err = res.unwrap_err().to_string();
+        assert!(err.contains("draft voyage"), "{err}");
+        assert!(err.contains("E1/V1"), "{err}");
+    }
+
+    #[test]
+    fn test_mission_resume_fails_with_draft_voyage() {
+        let temp = TestBoardBuilder::new()
+            .mission(TestMission::new("M1").title("Mission One").status("paused"))
+            .epic(TestEpic::new("E1").mission("M1"))
+            .voyage(TestVoyage::new("V1", "E1").status("draft"))
+            .build();
+
+        let res = MissionLifecycleService::resume(temp.path(), "M1");
+        assert!(res.is_err());
+        let err = res.unwrap_err().to_string();
+        assert!(err.contains("draft voyage"), "{err}");
+        assert!(err.contains("E1/V1"), "{err}");
+    }
+
     #[test]
     fn test_mission_activate_allows_bearing_without_planned_epic() {
         let temp = TestBoardBuilder::new()

crates/keel-core/src/domain/state_machine/gating.rs

@@ -72,6 +72,11 @@ pub fn evaluate_mission_transition(
 ) -> Vec<Problem> {
     match transition {
         MissionTransition::Activate => evaluate_mission_activation(board, mission),
+        MissionTransition::Resume => {
+            crate::infrastructure::validation::missions::check_mission_draft_voyage_coherence(
+                board, mission,
+            )
+        }
         MissionTransition::Achieve => evaluate_mission_achieve(board, mission),
         MissionTransition::Verify => evaluate_mission_verification(board, mission),
         _ => Vec::new(),
@@ -121,6 +126,12 @@ fn evaluate_mission_activation(
         ),
     );
 
+    problems.extend(
+        crate::infrastructure::validation::missions::check_mission_draft_voyage_coherence(
+            board, mission,
+        ),
+    );
+
     problems.extend(
         crate::infrastructure::validation::charter::check_mission_charter_readiness(board, mission),
     );

crates/keel-core/src/infrastructure/validation/missions.rs

@@ -1,4 +1,4 @@
-use crate::domain::model::{Board, EpicState, Mission};
+use crate::domain::model::{Board, EpicState, Mission, VoyageState};
 
 use super::{CheckId, GapCategory, Problem};
 
@@ -35,6 +35,36 @@ pub fn check_mission_actionable_lineage_readiness(
     ]
 }
 
+/// Active missions must not carry draft voyages in linked epics.
+pub fn check_mission_draft_voyage_coherence(board: &Board, mission: &Mission) -> Vec<Problem> {
+    let mut draft_voyages: Vec<_> = board
+        .epics_for_mission(mission.id())
+        .into_iter()
+        .flat_map(|epic| board.voyages_for_epic_id(epic.id()))
+        .filter(|voyage| voyage.status() == VoyageState::Draft)
+        .map(|voyage| voyage.scope_path())
+        .collect();
+    draft_voyages.sort();
+
+    if draft_voyages.is_empty() {
+        return Vec::new();
+    }
+
+    vec![
+        Problem::error(
+            mission.path.clone(),
+            format!(
+                "Mission {} cannot be active while linked epics contain draft voyage(s): {}. Plan or remove draft voyages before activating or continuing the mission.",
+                mission.id(),
+                draft_voyages.join(", "),
+            ),
+        )
+        .with_scope(mission.id())
+        .with_category(GapCategory::Coherence)
+        .with_check_id(CheckId::MissionDraftVoyageCoherence),
+    ]
+}
+
 pub fn mission_non_terminal_children(board: &Board, mission: &Mission) -> Vec<String> {
     let mut children = Vec::new();
 

crates/keel-core/src/infrastructure/validation/types.rs

@@ -223,6 +223,7 @@ pub enum CheckId {
     BearingDanglingDependency,
     BearingDependencyCycle,
     MissionDefinitionReadiness,
+    MissionDraftVoyageCoherence,
     MissionGoalAchieved,
     MissionActiveNoWork,
     MissionOrphanedLineage,

crates/keel-core/src/read_model/diagnostics/catalog.rs

@@ -321,6 +321,11 @@ pub const ALL_DOCTOR_CHECKS: &[DoctorCheckDefinition] = &[
         section: "Missions",
         name: "Active mission work coherence",
     },
+    DoctorCheckDefinition {
+        id: "mission-active-draft-voyages",
+        section: "Missions",
+        name: "Active mission draft voyages",
+    },
     DoctorCheckDefinition {
         id: "mission-orphaned-lineage",
         section: "Missions",

crates/keel-core/src/read_model/diagnostics/checks/missions.rs

@@ -421,6 +421,23 @@ pub fn check_mission_active_no_work(board: &Board) -> Vec<Problem> {
     problems
 }
 
+/// Check for active missions carrying draft voyages in linked epics.
+pub fn check_mission_active_draft_voyages(board: &Board) -> Vec<Problem> {
+    let mut problems = Vec::new();
+
+    for mission in board.missions.values() {
+        if mission.status() != MissionStatus::Active {
+            continue;
+        }
+
+        problems.extend(missions::check_mission_draft_voyage_coherence(
+            board, mission,
+        ));
+    }
+
+    problems
+}
+
 /// Check for orphaned mission lineage
 pub fn check_mission_orphans(board: &Board) -> Vec<Problem> {
     let mut problems = Vec::new();
@@ -870,6 +887,38 @@ mod tests {
         assert_eq!(problems[0].severity, Severity::Error);
     }
 
+    #[test]
+    fn test_check_mission_active_draft_voyages_flags_active_mission() {
+        let temp = TestBoardBuilder::new()
+            .mission(TestMission::new("M1").status("active"))
+            .epic(TestEpic::new("E1").mission("M1"))
+            .voyage(TestVoyage::new("V1", "E1").status("draft"))
+            .build();
+
+        let board = load_board(temp.path()).unwrap();
+        let problems = check_mission_active_draft_voyages(&board);
+
+        assert_eq!(problems.len(), 1);
+        assert_eq!(problems[0].check_id, CheckId::MissionDraftVoyageCoherence);
+        assert_eq!(problems[0].severity, Severity::Error);
+        assert!(problems[0].message.contains("draft voyage"));
+        assert!(problems[0].message.contains("E1/V1"));
+    }
+
+    #[test]
+    fn test_check_mission_active_draft_voyages_ignores_defining_mission() {
+        let temp = TestBoardBuilder::new()
+            .mission(TestMission::new("M1").status("defining"))
+            .epic(TestEpic::new("E1").mission("M1"))
+            .voyage(TestVoyage::new("V1", "E1").status("draft"))
+            .build();
+
+        let board = load_board(temp.path()).unwrap();
+        let problems = check_mission_active_draft_voyages(&board);
+
+        assert!(problems.is_empty());
+    }
+
     #[test]
     fn test_check_mission_completion_evidence() {
         let temp = TestBoardBuilder::new()

crates/keel-core/src/read_model/diagnostics/mod.rs

@@ -666,6 +666,16 @@ fn validate_with_config_internal(
         mission_work_problems,
     ));
 
+    let mission_draft_voyage_problems =
+        checks::missions::check_mission_active_draft_voyages(&board);
+    mission_checks.push(configured_check(
+        doctor_config,
+        "mission-active-draft-voyages",
+        "Active mission draft voyages",
+        board.missions.len(),
+        mission_draft_voyage_problems,
+    ));
+
     let mission_orphan_problems = checks::missions::check_mission_orphans(&board);
     mission_checks.push(configured_check(
         doctor_config,