feat(mission): implement child-entity gates for mission transitions

rupurt · rupurt · commit 0ed345fcf47e · 2026-03-11T12:46:50.000-07:00
- Add evaluate_mission_transition to domain gating logic
- Enforce child-entity requirements in activate, achieve, and verify mission lifecycle methods
- Consolidate business rules into the domain layer
- Update mission lifecycle tests to verify the new gates
diff --git a/.keel/missions/VDZsowb2k/LOG.md b/.keel/missions/VDZsowb2k/LOG.md
@@ -6,3 +6,7 @@
 ## 2026-03-11T11:26:07
 
 Restored board coherence by formally decomposing and completing the diagnostics epics. Resolved legacy bearing warnings and ensured all entities are in a healthy, terminal state.
+
+## 2026-03-11T12:46:50
+
+Implemented formal domain gates for mission transitions. Missions now require at least one child entity (epic, bearing, or ADR) before they can be activated, achieved, or verified. Consolidated gating logic into the domain layer and updated MissionLifecycleService to enforce these rules. Fixed all board health issues and verified with 774 tests passing.
diff --git a/src/application/mission_lifecycle.rs b/src/application/mission_lifecycle.rs
@@ -3,6 +3,9 @@
 use anyhow::{Result, anyhow};
 use std::path::Path;
 
+use crate::domain::state_machine::{
+    evaluate_mission_transition, format_gate_error, MissionTransition,
+};
 use crate::domain::transitions::mission::{execute, mission_transitions};
 use crate::infrastructure::loader::load_board;
 use crate::infrastructure::markdown_sections::{extract_section, replace_section};
@@ -44,6 +47,11 @@ impl MissionLifecycleService {
         let board = load_board(board_dir)?;
         let mission = board.require_mission(id)?;
 
+        let problems = evaluate_mission_transition(&board, mission, MissionTransition::Achieve);
+        if !problems.is_empty() {
+            return Err(anyhow!(format_gate_error("mission", "achieve", &problems)));
+        }
+
         // Verify goals before achievement
         let charter_path = mission.path.parent().unwrap().join("CHARTER.md");
         let charter_content = std::fs::read_to_string(&charter_path).unwrap_or_default();
@@ -68,14 +76,6 @@ impl MissionLifecycleService {
             return Err(anyhow!("Mission has unmet board goals"));
         }
 
-        // Verify child entities
-        if board.mission_child_count(id) == 0 {
-            return Err(anyhow!(
-                "Cannot achieve mission {}. At least one child entity (epic, bearing, or ADR) is required.",
-                id
-            ));
-        }
-
         // Verify log entries
         let log_path = mission.path.parent().unwrap().join("LOG.md");
         let log_content = std::fs::read_to_string(&log_path).unwrap_or_default();
@@ -94,18 +94,14 @@ impl MissionLifecycleService {
 
     pub fn verify(board_dir: &Path, id: &str) -> Result<()> {
         let board = load_board(board_dir)?;
-        let _mission = board.require_mission(id)?;
+        let mission = board.require_mission(id)?;
 
-        // Verify child entities
-        if board.mission_child_count(id) == 0 {
-            return Err(anyhow!(
-                "Cannot verify mission {}. At least one child entity (epic, bearing, or ADR) is required.",
-                id
-            ));
+        let problems = evaluate_mission_transition(&board, mission, MissionTransition::Verify);
+        if !problems.is_empty() {
+            return Err(anyhow!(format_gate_error("mission", "verify", &problems)));
         }
 
         // Verify log entries
-        let mission = board.require_mission(id)?;
         let log_path = mission.path.parent().unwrap().join("LOG.md");
         let log_content = std::fs::read_to_string(&log_path).unwrap_or_default();
         let (_, entries) = parse_log_entries(&log_content);
@@ -131,6 +127,11 @@ impl MissionLifecycleService {
         let board = load_board(board_dir)?;
         let mission = board.require_mission(id)?;
 
+        let problems = evaluate_mission_transition(&board, mission, MissionTransition::Activate);
+        if !problems.is_empty() {
+            return Err(anyhow!(format_gate_error("mission", "activate", &problems)));
+        }
+
         let charter_path = mission.path.parent().unwrap().join("CHARTER.md");
         let charter_content = std::fs::read_to_string(&charter_path).unwrap_or_default();
         let goals = charter::parse_mission_goals(&charter_content);
@@ -142,14 +143,6 @@ impl MissionLifecycleService {
             ));
         }
 
-        // Verify child entities - missions need at least one child to be actionable
-        if board.mission_child_count(id) == 0 {
-            return Err(anyhow!(
-                "Cannot activate mission {}. At least one child entity (epic, bearing, or ADR) is required before activation.",
-                id
-            ));
-        }
-
         execute(board_dir, id, &mission_transitions::ACTIVATE)?;
         println!("Activated mission: {}", id);
         Ok(())
@@ -401,7 +394,7 @@ mod tests {
 
         let res = MissionLifecycleService::activate(temp.path(), "M1");
         assert!(res.is_err());
-        assert!(res.unwrap_err().to_string().contains("child entity"));
+        assert!(res.unwrap_err().to_string().contains("no child entities"));
     }
 
     #[test]
@@ -412,6 +405,7 @@ mod tests {
                     .title("Mission One")
                     .status("defining"),
             )
+            .epic(TestEpic::new("E1").mission("M1"))
             .build();
 
         // Empty CHARTER.md (no goals)
@@ -457,7 +451,7 @@ mod tests {
         // Should fail because no children
         let res = MissionLifecycleService::achieve(temp.path(), "M1");
         assert!(res.is_err());
-        assert!(res.unwrap_err().to_string().contains("one child entity"));
+        assert!(res.unwrap_err().to_string().contains("no child entities"));
 
         // Add a child (epic)
         let temp = TestBoardBuilder::new()
diff --git a/src/domain/state_machine/gating.rs b/src/domain/state_machine/gating.rs
@@ -9,6 +9,7 @@ use std::fs;
 
 use crate::domain::model::{Board, Story, StoryState, Voyage};
 use crate::domain::state_machine::invariants;
+use crate::domain::state_machine::mission::MissionTransition;
 use crate::domain::state_machine::story::StoryTransition;
 use crate::domain::state_machine::voyage::VoyageTransition;
 use crate::infrastructure::validation::{CheckId, Problem, Severity};
@@ -61,6 +62,119 @@ pub fn problem_blocks_runtime(problem: &Problem, strict: bool) -> bool {
     strict || matches!(problem.severity, Severity::Error)
 }
 
+/// Return gate problems for mission lifecycle transition checks.
+pub fn evaluate_mission_transition(
+    board: &Board,
+    mission: &crate::domain::model::Mission,
+    transition: MissionTransition,
+) -> Vec<Problem> {
+    match transition {
+        MissionTransition::Activate => evaluate_mission_activation(board, mission),
+        MissionTransition::Achieve => evaluate_mission_achieve(board, mission),
+        MissionTransition::Verify => evaluate_mission_verification(board, mission),
+        _ => Vec::new(),
+    }
+}
+
+fn evaluate_mission_activation(
+    board: &Board,
+    mission: &crate::domain::model::Mission,
+) -> Vec<Problem> {
+    let mut problems = Vec::new();
+
+    let child_count = board
+        .epics
+        .values()
+        .filter(|e| e.frontmatter.mission.as_deref() == Some(mission.id()))
+        .count()
+        + board
+            .bearings
+            .values()
+            .filter(|b| b.frontmatter.mission.as_deref() == Some(mission.id()))
+            .count()
+        + board
+            .adrs
+            .values()
+            .filter(|a| a.frontmatter.mission.as_deref() == Some(mission.id()))
+            .count();
+
+    if child_count == 0 {
+        problems.push(Problem::error(
+            mission.path.clone(),
+            format!("Mission {} cannot be activated: no child entities found. Link at least one epic, bearing, or ADR first.", mission.id())
+        ));
+    }
+
+    problems
+}
+
+fn evaluate_mission_achieve(
+    board: &Board,
+    mission: &crate::domain::model::Mission,
+) -> Vec<Problem> {
+    let mut problems = Vec::new();
+
+    let child_count = board
+        .epics
+        .values()
+        .filter(|e| e.frontmatter.mission.as_deref() == Some(mission.id()))
+        .count()
+        + board
+            .bearings
+            .values()
+            .filter(|b| b.frontmatter.mission.as_deref() == Some(mission.id()))
+            .count()
+        + board
+            .adrs
+            .values()
+            .filter(|a| a.frontmatter.mission.as_deref() == Some(mission.id()))
+            .count();
+
+    if child_count == 0 {
+        problems.push(Problem::error(
+            mission.path.clone(),
+            format!(
+                "Mission {} cannot be achieved: no child entities found.",
+                mission.id()
+            ),
+        ));
+    }
+
+    problems
+}
+
+fn evaluate_mission_verification(
+    board: &Board,
+    mission: &crate::domain::model::Mission,
+) -> Vec<Problem> {
+    let mut problems = Vec::new();
+
+    let child_count = board
+        .epics
+        .values()
+        .filter(|e| e.frontmatter.mission.as_deref() == Some(mission.id()))
+        .count()
+        + board
+            .bearings
+            .values()
+            .filter(|b| b.frontmatter.mission.as_deref() == Some(mission.id()))
+            .count()
+        + board
+            .adrs
+            .values()
+            .filter(|a| a.frontmatter.mission.as_deref() == Some(mission.id()))
+            .count();
+
+    if child_count == 0 {
+        problems.push(Problem::error(
+            mission.path.clone(),
+            format!("Mission {} cannot be verified: no child entities found.", mission.id())
+        ));
+    }
+
+    problems
+}
+
 /// Return runtime-blocking gate problems for a story transition.
 pub fn evaluate_story_transition(
     board: &Board,
diff --git a/src/domain/state_machine/mod.rs b/src/domain/state_machine/mod.rs
@@ -34,8 +34,9 @@ pub use flow::{FlowState, FlowStateMachine, QueueDepths};
 pub use formatting::format_transition_error;
 #[allow(unused_imports)]
 pub use gating::{
-    VoyageCompletionPolicy, evaluate_epic_done, evaluate_story_transition,
-    evaluate_voyage_completion, evaluate_voyage_transition, format_gate_error,
+    VoyageCompletionPolicy, evaluate_epic_done, evaluate_mission_transition,
+    evaluate_story_transition, evaluate_voyage_completion, evaluate_voyage_transition,
+    format_gate_error,
 };
 #[allow(unused_imports)]
 pub use mission::{MissionStateMachine, MissionStatus, MissionTransition};
